//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2022 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

import Foundation
import SotoCore

extension Lambda {
    // MARK: Enums

    public enum Architecture: String, CustomStringConvertible, Codable, _SotoSendable {
        case arm64
        case x8664 = "x86_64"
        public var description: String { return self.rawValue }
    }

    public enum CodeSigningPolicy: String, CustomStringConvertible, Codable, _SotoSendable {
        case enforce = "Enforce"
        case warn = "Warn"
        public var description: String { return self.rawValue }
    }

    public enum EndPointType: String, CustomStringConvertible, Codable, _SotoSendable {
        case kafkaBootstrapServers = "KAFKA_BOOTSTRAP_SERVERS"
        public var description: String { return self.rawValue }
    }

    public enum EventSourcePosition: String, CustomStringConvertible, Codable, _SotoSendable {
        case atTimestamp = "AT_TIMESTAMP"
        case latest = "LATEST"
        case trimHorizon = "TRIM_HORIZON"
        public var description: String { return self.rawValue }
    }

    public enum FunctionResponseType: String, CustomStringConvertible, Codable, _SotoSendable {
        case reportBatchItemFailures = "ReportBatchItemFailures"
        public var description: String { return self.rawValue }
    }

    public enum FunctionUrlAuthType: String, CustomStringConvertible, Codable, _SotoSendable {
        case awsIam = "AWS_IAM"
        case none = "NONE"
        public var description: String { return self.rawValue }
    }

    public enum FunctionVersion: String, CustomStringConvertible, Codable, _SotoSendable {
        case all = "ALL"
        public var description: String { return self.rawValue }
    }

    public enum InvocationType: String, CustomStringConvertible, Codable, _SotoSendable {
        case dryRun = "DryRun"
        case event = "Event"
        case requestResponse = "RequestResponse"
        public var description: String { return self.rawValue }
    }

    public enum LastUpdateStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case failed = "Failed"
        case inProgress = "InProgress"
        case successful = "Successful"
        public var description: String { return self.rawValue }
    }

    public enum LastUpdateStatusReasonCode: String, CustomStringConvertible, Codable, _SotoSendable {
        case disabledKMSKey = "DisabledKMSKey"
        case efsMountConnectivityError = "EFSMountConnectivityError"
        case efsMountFailure = "EFSMountFailure"
        case efsMountTimeout = "EFSMountTimeout"
        case efsioError = "EFSIOError"
        case eniLimitExceeded = "EniLimitExceeded"
        case functionError = "FunctionError"
        case imageAccessDenied = "ImageAccessDenied"
        case imageDeleted = "ImageDeleted"
        case insufficientRolePermissions = "InsufficientRolePermissions"
        case internalError = "InternalError"
        case invalidConfiguration = "InvalidConfiguration"
        case invalidImage = "InvalidImage"
        case invalidRuntime = "InvalidRuntime"
        case invalidSecurityGroup = "InvalidSecurityGroup"
        case invalidStateKMSKey = "InvalidStateKMSKey"
        case invalidSubnet = "InvalidSubnet"
        case invalidZipFileException = "InvalidZipFileException"
        case kmsKeyAccessDenied = "KMSKeyAccessDenied"
        case kmsKeyNotFound = "KMSKeyNotFound"
        case subnetOutOfIPAddresses = "SubnetOutOfIPAddresses"
        public var description: String { return self.rawValue }
    }

    public enum LogType: String, CustomStringConvertible, Codable, _SotoSendable {
        case none = "None"
        case tail = "Tail"
        public var description: String { return self.rawValue }
    }

    public enum PackageType: String, CustomStringConvertible, Codable, _SotoSendable {
        case image = "Image"
        case zip = "Zip"
        public var description: String { return self.rawValue }
    }

    public enum ProvisionedConcurrencyStatusEnum: String, CustomStringConvertible, Codable, _SotoSendable {
        case failed = "FAILED"
        case inProgress = "IN_PROGRESS"
        case ready = "READY"
        public var description: String { return self.rawValue }
    }

    public enum Runtime: String, CustomStringConvertible, Codable, _SotoSendable {
        case dotnet6
        case dotnetcore10 = "dotnetcore1.0"
        case dotnetcore20 = "dotnetcore2.0"
        case dotnetcore21 = "dotnetcore2.1"
        case dotnetcore31 = "dotnetcore3.1"
        case go1x = "go1.x"
        case java11
        case java8
        case java8al2 = "java8.al2"
        case nodejs
        case nodejs10x = "nodejs10.x"
        case nodejs12x = "nodejs12.x"
        case nodejs14x = "nodejs14.x"
        case nodejs16x = "nodejs16.x"
        case nodejs18x = "nodejs18.x"
        case nodejs43 = "nodejs4.3"
        case nodejs43edge = "nodejs4.3-edge"
        case nodejs610 = "nodejs6.10"
        case nodejs810 = "nodejs8.10"
        case provided
        case providedal2 = "provided.al2"
        case python27 = "python2.7"
        case python36 = "python3.6"
        case python37 = "python3.7"
        case python38 = "python3.8"
        case python39 = "python3.9"
        case ruby25 = "ruby2.5"
        case ruby27 = "ruby2.7"
        public var description: String { return self.rawValue }
    }

    public enum SnapStartApplyOn: String, CustomStringConvertible, Codable, _SotoSendable {
        case none = "None"
        case publishedVersions = "PublishedVersions"
        public var description: String { return self.rawValue }
    }

    public enum SnapStartOptimizationStatus: String, CustomStringConvertible, Codable, _SotoSendable {
        case off = "Off"
        case on = "On"
        public var description: String { return self.rawValue }
    }

    public enum SourceAccessType: String, CustomStringConvertible, Codable, _SotoSendable {
        case basicAuth = "BASIC_AUTH"
        case clientCertificateTlsAuth = "CLIENT_CERTIFICATE_TLS_AUTH"
        case saslScram256Auth = "SASL_SCRAM_256_AUTH"
        case saslScram512Auth = "SASL_SCRAM_512_AUTH"
        case serverRootCaCertificate = "SERVER_ROOT_CA_CERTIFICATE"
        case virtualHost = "VIRTUAL_HOST"
        case vpcSecurityGroup = "VPC_SECURITY_GROUP"
        case vpcSubnet = "VPC_SUBNET"
        public var description: String { return self.rawValue }
    }

    public enum State: String, CustomStringConvertible, Codable, _SotoSendable {
        case active = "Active"
        case failed = "Failed"
        case inactive = "Inactive"
        case pending = "Pending"
        public var description: String { return self.rawValue }
    }

    public enum StateReasonCode: String, CustomStringConvertible, Codable, _SotoSendable {
        case creating = "Creating"
        case disabledKMSKey = "DisabledKMSKey"
        case efsMountConnectivityError = "EFSMountConnectivityError"
        case efsMountFailure = "EFSMountFailure"
        case efsMountTimeout = "EFSMountTimeout"
        case efsioError = "EFSIOError"
        case eniLimitExceeded = "EniLimitExceeded"
        case functionError = "FunctionError"
        case idle = "Idle"
        case imageAccessDenied = "ImageAccessDenied"
        case imageDeleted = "ImageDeleted"
        case insufficientRolePermissions = "InsufficientRolePermissions"
        case internalError = "InternalError"
        case invalidConfiguration = "InvalidConfiguration"
        case invalidImage = "InvalidImage"
        case invalidRuntime = "InvalidRuntime"
        case invalidSecurityGroup = "InvalidSecurityGroup"
        case invalidStateKMSKey = "InvalidStateKMSKey"
        case invalidSubnet = "InvalidSubnet"
        case invalidZipFileException = "InvalidZipFileException"
        case kmsKeyAccessDenied = "KMSKeyAccessDenied"
        case kmsKeyNotFound = "KMSKeyNotFound"
        case restoring = "Restoring"
        case subnetOutOfIPAddresses = "SubnetOutOfIPAddresses"
        public var description: String { return self.rawValue }
    }

    public enum TracingMode: String, CustomStringConvertible, Codable, _SotoSendable {
        case active = "Active"
        case passThrough = "PassThrough"
        public var description: String { return self.rawValue }
    }

    // MARK: Shapes

    public struct AccountLimit: AWSDecodableShape {
        /// The maximum size of a function's deployment package and layers when they're extracted.
        public let codeSizeUnzipped: Int64?
        /// The maximum size of a deployment package when it's uploaded directly to Lambda. Use Amazon S3 for larger files.
        public let codeSizeZipped: Int64?
        /// The maximum number of simultaneous function executions.
        public let concurrentExecutions: Int?
        /// The amount of storage space that you can use for all deployment packages and layer archives.
        public let totalCodeSize: Int64?
        /// The maximum number of simultaneous function executions, minus the capacity that's reserved for individual functions with PutFunctionConcurrency.
        public let unreservedConcurrentExecutions: Int?

        public init(codeSizeUnzipped: Int64? = nil, codeSizeZipped: Int64? = nil, concurrentExecutions: Int? = nil, totalCodeSize: Int64? = nil, unreservedConcurrentExecutions: Int? = nil) {
            self.codeSizeUnzipped = codeSizeUnzipped
            self.codeSizeZipped = codeSizeZipped
            self.concurrentExecutions = concurrentExecutions
            self.totalCodeSize = totalCodeSize
            self.unreservedConcurrentExecutions = unreservedConcurrentExecutions
        }

        private enum CodingKeys: String, CodingKey {
            case codeSizeUnzipped = "CodeSizeUnzipped"
            case codeSizeZipped = "CodeSizeZipped"
            case concurrentExecutions = "ConcurrentExecutions"
            case totalCodeSize = "TotalCodeSize"
            case unreservedConcurrentExecutions = "UnreservedConcurrentExecutions"
        }
    }

    public struct AccountUsage: AWSDecodableShape {
        /// The number of Lambda functions.
        public let functionCount: Int64?
        /// The amount of storage space, in bytes, that's being used by deployment packages and layer archives.
        public let totalCodeSize: Int64?

        public init(functionCount: Int64? = nil, totalCodeSize: Int64? = nil) {
            self.functionCount = functionCount
            self.totalCodeSize = totalCodeSize
        }

        private enum CodingKeys: String, CodingKey {
            case functionCount = "FunctionCount"
            case totalCodeSize = "TotalCodeSize"
        }
    }

    public struct AddLayerVersionPermissionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "layerName", location: .uri("LayerName")),
            AWSMemberEncoding(label: "revisionId", location: .querystring("RevisionId")),
            AWSMemberEncoding(label: "versionNumber", location: .uri("VersionNumber"))
        ]

        /// The API action that grants access to the layer. For example, lambda:GetLayerVersion.
        public let action: String
        /// The name or Amazon Resource Name (ARN) of the layer.
        public let layerName: String
        /// With the principal set to *, grant permission to all accounts in the specified organization.
        public let organizationId: String?
        /// An account ID, or * to grant layer usage permission to all accounts in an organization, or all Amazon Web Services accounts (if organizationId is not specified). For the last case, make sure that you really do want all Amazon Web Services accounts to have usage permission to this layer.
        public let principal: String
        /// Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a policy that has changed since you last read it.
        public let revisionId: String?
        /// An identifier that distinguishes the policy from others on the same layer version.
        public let statementId: String
        /// The version number.
        public let versionNumber: Int64

        public init(action: String, layerName: String, organizationId: String? = nil, principal: String, revisionId: String? = nil, statementId: String, versionNumber: Int64 = 0) {
            self.action = action
            self.layerName = layerName
            self.organizationId = organizationId
            self.principal = principal
            self.revisionId = revisionId
            self.statementId = statementId
            self.versionNumber = versionNumber
        }

        public func validate(name: String) throws {
            try self.validate(self.action, name: "action", parent: name, max: 22)
            try self.validate(self.action, name: "action", parent: name, pattern: "^lambda:GetLayerVersion$")
            try self.validate(self.layerName, name: "layerName", parent: name, max: 140)
            try self.validate(self.layerName, name: "layerName", parent: name, min: 1)
            try self.validate(self.layerName, name: "layerName", parent: name, pattern: "^(arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+)|[a-zA-Z0-9-_]+$")
            try self.validate(self.organizationId, name: "organizationId", parent: name, max: 34)
            try self.validate(self.organizationId, name: "organizationId", parent: name, pattern: "^o-[a-z0-9]{10,32}$")
            try self.validate(self.principal, name: "principal", parent: name, pattern: "^\\d{12}|\\*|arn:(aws[a-zA-Z-]*):iam::\\d{12}:root$")
            try self.validate(self.statementId, name: "statementId", parent: name, max: 100)
            try self.validate(self.statementId, name: "statementId", parent: name, min: 1)
            try self.validate(self.statementId, name: "statementId", parent: name, pattern: "^([a-zA-Z0-9-_]+)$")
        }

        private enum CodingKeys: String, CodingKey {
            case action = "Action"
            case organizationId = "OrganizationId"
            case principal = "Principal"
            case statementId = "StatementId"
        }
    }

    public struct AddLayerVersionPermissionResponse: AWSDecodableShape {
        /// A unique identifier for the current revision of the policy.
        public let revisionId: String?
        /// The permission statement.
        public let statement: String?

        public init(revisionId: String? = nil, statement: String? = nil) {
            self.revisionId = revisionId
            self.statement = statement
        }

        private enum CodingKeys: String, CodingKey {
            case revisionId = "RevisionId"
            case statement = "Statement"
        }
    }

    public struct AddPermissionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The action that the principal can use on the function. For example, lambda:InvokeFunction or lambda:GetFunction.
        public let action: String
        /// For Alexa Smart Home functions, a token that the invoker must supply.
        public let eventSourceToken: String?
        /// The name of the Lambda function, version, or alias.  Name formats     Function name – my-function (name-only), my-function:v1 (with alias).    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The type of authentication that your function URL uses. Set to AWS_IAM if you want to restrict access to authenticated IAM users only. Set to NONE if you want to bypass IAM authentication to create a public endpoint. For more information, see Security and auth model for Lambda function URLs.
        public let functionUrlAuthType: FunctionUrlAuthType?
        /// The Amazon Web Service or Amazon Web Services account that invokes the function. If you specify a service, use SourceArn or SourceAccount to limit who can invoke the function through that service.
        public let principal: String
        /// The identifier for your organization in Organizations. Use this to grant permissions to all the Amazon Web Services accounts under this organization.
        public let principalOrgID: String?
        /// Specify a version or alias to add permissions to a published version of the function.
        public let qualifier: String?
        /// Update the policy only if the revision ID matches the ID that's specified. Use this option to avoid modifying a policy that has changed since you last read it.
        public let revisionId: String?
        /// For Amazon Web Service, the ID of the Amazon Web Services account that owns the resource. Use this together with SourceArn to ensure that the specified account owns the resource. It is possible for an Amazon S3 bucket to be deleted by its owner and recreated by another account.
        public let sourceAccount: String?
        /// For Amazon Web Services, the ARN of the Amazon Web Services resource that invokes the function. For example, an Amazon S3 bucket or Amazon SNS topic. Note that Lambda configures the comparison using the StringLike operator.
        public let sourceArn: String?
        /// A statement identifier that differentiates the statement from others in the same policy.
        public let statementId: String

        public init(action: String, eventSourceToken: String? = nil, functionName: String, functionUrlAuthType: FunctionUrlAuthType? = nil, principal: String, principalOrgID: String? = nil, qualifier: String? = nil, revisionId: String? = nil, sourceAccount: String? = nil, sourceArn: String? = nil, statementId: String) {
            self.action = action
            self.eventSourceToken = eventSourceToken
            self.functionName = functionName
            self.functionUrlAuthType = functionUrlAuthType
            self.principal = principal
            self.principalOrgID = principalOrgID
            self.qualifier = qualifier
            self.revisionId = revisionId
            self.sourceAccount = sourceAccount
            self.sourceArn = sourceArn
            self.statementId = statementId
        }

        public func validate(name: String) throws {
            try self.validate(self.action, name: "action", parent: name, pattern: "^(lambda:[*]|lambda:[a-zA-Z]+|[*])$")
            try self.validate(self.eventSourceToken, name: "eventSourceToken", parent: name, max: 256)
            try self.validate(self.eventSourceToken, name: "eventSourceToken", parent: name, pattern: "^[a-zA-Z0-9._\\-]+$")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.principal, name: "principal", parent: name, pattern: "^[^\\s]+$")
            try self.validate(self.principalOrgID, name: "principalOrgID", parent: name, max: 34)
            try self.validate(self.principalOrgID, name: "principalOrgID", parent: name, min: 12)
            try self.validate(self.principalOrgID, name: "principalOrgID", parent: name, pattern: "^o-[a-z0-9]{10,32}$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
            try self.validate(self.sourceAccount, name: "sourceAccount", parent: name, max: 12)
            try self.validate(self.sourceAccount, name: "sourceAccount", parent: name, pattern: "^\\d{12}$")
            try self.validate(self.sourceArn, name: "sourceArn", parent: name, pattern: "^arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\\-])+:([a-z]{2}(-gov)?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)$")
            try self.validate(self.statementId, name: "statementId", parent: name, max: 100)
            try self.validate(self.statementId, name: "statementId", parent: name, min: 1)
            try self.validate(self.statementId, name: "statementId", parent: name, pattern: "^([a-zA-Z0-9-_]+)$")
        }

        private enum CodingKeys: String, CodingKey {
            case action = "Action"
            case eventSourceToken = "EventSourceToken"
            case functionUrlAuthType = "FunctionUrlAuthType"
            case principal = "Principal"
            case principalOrgID = "PrincipalOrgID"
            case revisionId = "RevisionId"
            case sourceAccount = "SourceAccount"
            case sourceArn = "SourceArn"
            case statementId = "StatementId"
        }
    }

    public struct AddPermissionResponse: AWSDecodableShape {
        /// The permission statement that's added to the function policy.
        public let statement: String?

        public init(statement: String? = nil) {
            self.statement = statement
        }

        private enum CodingKeys: String, CodingKey {
            case statement = "Statement"
        }
    }

    public struct AliasConfiguration: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the alias.
        public let aliasArn: String?
        /// A description of the alias.
        public let description: String?
        /// The function version that the alias invokes.
        public let functionVersion: String?
        /// The name of the alias.
        public let name: String?
        /// A unique identifier that changes when you update the alias.
        public let revisionId: String?
        /// The routing configuration of the alias.
        public let routingConfig: AliasRoutingConfiguration?

        public init(aliasArn: String? = nil, description: String? = nil, functionVersion: String? = nil, name: String? = nil, revisionId: String? = nil, routingConfig: AliasRoutingConfiguration? = nil) {
            self.aliasArn = aliasArn
            self.description = description
            self.functionVersion = functionVersion
            self.name = name
            self.revisionId = revisionId
            self.routingConfig = routingConfig
        }

        private enum CodingKeys: String, CodingKey {
            case aliasArn = "AliasArn"
            case description = "Description"
            case functionVersion = "FunctionVersion"
            case name = "Name"
            case revisionId = "RevisionId"
            case routingConfig = "RoutingConfig"
        }
    }

    public struct AliasRoutingConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// The second version, and the percentage of traffic that's routed to it.
        public let additionalVersionWeights: [String: Double]?

        public init(additionalVersionWeights: [String: Double]? = nil) {
            self.additionalVersionWeights = additionalVersionWeights
        }

        public func validate(name: String) throws {
            try self.additionalVersionWeights?.forEach {
                try validate($0.key, name: "additionalVersionWeights.key", parent: name, max: 1024)
                try validate($0.key, name: "additionalVersionWeights.key", parent: name, min: 1)
                try validate($0.key, name: "additionalVersionWeights.key", parent: name, pattern: "^[0-9]+$")
                try validate($0.value, name: "additionalVersionWeights[\"\($0.key)\"]", parent: name, max: 1.0)
                try validate($0.value, name: "additionalVersionWeights[\"\($0.key)\"]", parent: name, min: 0.0)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case additionalVersionWeights = "AdditionalVersionWeights"
        }
    }

    public struct AllowedPublishers: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) for each of the signing profiles. A signing profile defines a trusted user who can sign a code package.
        public let signingProfileVersionArns: [String]

        public init(signingProfileVersionArns: [String]) {
            self.signingProfileVersionArns = signingProfileVersionArns
        }

        public func validate(name: String) throws {
            try self.signingProfileVersionArns.forEach {
                try validate($0, name: "signingProfileVersionArns[]", parent: name, pattern: "^arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\\-])+:([a-z]{2}(-gov)?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)$")
            }
            try self.validate(self.signingProfileVersionArns, name: "signingProfileVersionArns", parent: name, max: 20)
            try self.validate(self.signingProfileVersionArns, name: "signingProfileVersionArns", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case signingProfileVersionArns = "SigningProfileVersionArns"
        }
    }

    public struct AmazonManagedKafkaEventSourceConfig: AWSEncodableShape & AWSDecodableShape {
        /// The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. For more information, see Customizable consumer group ID.
        public let consumerGroupId: String?

        public init(consumerGroupId: String? = nil) {
            self.consumerGroupId = consumerGroupId
        }

        public func validate(name: String) throws {
            try self.validate(self.consumerGroupId, name: "consumerGroupId", parent: name, max: 200)
            try self.validate(self.consumerGroupId, name: "consumerGroupId", parent: name, min: 1)
            try self.validate(self.consumerGroupId, name: "consumerGroupId", parent: name, pattern: "^[a-zA-Z0-9-\\/*:_+=.@-]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case consumerGroupId = "ConsumerGroupId"
        }
    }

    public struct CodeSigningConfig: AWSDecodableShape {
        /// List of allowed publishers.
        public let allowedPublishers: AllowedPublishers
        /// The Amazon Resource Name (ARN) of the Code signing configuration.
        public let codeSigningConfigArn: String
        /// Unique identifer for the Code signing configuration.
        public let codeSigningConfigId: String
        /// The code signing policy controls the validation failure action for signature mismatch or expiry.
        public let codeSigningPolicies: CodeSigningPolicies
        /// Code signing configuration description.
        public let description: String?
        /// The date and time that the Code signing configuration was last modified, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let lastModified: String

        public init(allowedPublishers: AllowedPublishers, codeSigningConfigArn: String, codeSigningConfigId: String, codeSigningPolicies: CodeSigningPolicies, description: String? = nil, lastModified: String) {
            self.allowedPublishers = allowedPublishers
            self.codeSigningConfigArn = codeSigningConfigArn
            self.codeSigningConfigId = codeSigningConfigId
            self.codeSigningPolicies = codeSigningPolicies
            self.description = description
            self.lastModified = lastModified
        }

        private enum CodingKeys: String, CodingKey {
            case allowedPublishers = "AllowedPublishers"
            case codeSigningConfigArn = "CodeSigningConfigArn"
            case codeSigningConfigId = "CodeSigningConfigId"
            case codeSigningPolicies = "CodeSigningPolicies"
            case description = "Description"
            case lastModified = "LastModified"
        }
    }

    public struct CodeSigningPolicies: AWSEncodableShape & AWSDecodableShape {
        /// Code signing configuration policy for deployment validation failure. If you set the policy to Enforce, Lambda blocks the deployment request if signature validation checks fail. If you set the policy to Warn, Lambda allows the deployment and creates a CloudWatch log.  Default value: Warn
        public let untrustedArtifactOnDeployment: CodeSigningPolicy?

        public init(untrustedArtifactOnDeployment: CodeSigningPolicy? = nil) {
            self.untrustedArtifactOnDeployment = untrustedArtifactOnDeployment
        }

        private enum CodingKeys: String, CodingKey {
            case untrustedArtifactOnDeployment = "UntrustedArtifactOnDeployment"
        }
    }

    public struct Concurrency: AWSDecodableShape {
        /// The number of concurrent executions that are reserved for this function. For more information, see Managing Lambda reserved concurrency.
        public let reservedConcurrentExecutions: Int?

        public init(reservedConcurrentExecutions: Int? = nil) {
            self.reservedConcurrentExecutions = reservedConcurrentExecutions
        }

        private enum CodingKeys: String, CodingKey {
            case reservedConcurrentExecutions = "ReservedConcurrentExecutions"
        }
    }

    public struct Cors: AWSEncodableShape & AWSDecodableShape {
        /// Whether to allow cookies or other credentials in requests to your function URL. The default is false.
        public let allowCredentials: Bool?
        /// The HTTP headers that origins can include in requests to your function URL. For example: Date, Keep-Alive, X-Custom-Header.
        public let allowHeaders: [String]?
        /// The HTTP methods that are allowed when calling your function URL. For example: GET, POST, DELETE, or the wildcard character (*).
        public let allowMethods: [String]?
        /// The origins that can access your function URL. You can list any number of specific origins, separated by a comma. For example: https://www.example.com, http://localhost:60905. Alternatively, you can grant access to all origins using the wildcard character (*).
        public let allowOrigins: [String]?
        /// The HTTP headers in your function response that you want to expose to origins that call your function URL. For example: Date, Keep-Alive, X-Custom-Header.
        public let exposeHeaders: [String]?
        /// The maximum amount of time, in seconds, that web browsers can cache results of a preflight request. By default, this is set to 0, which means that the browser doesn't cache results.
        public let maxAge: Int?

        public init(allowCredentials: Bool? = nil, allowHeaders: [String]? = nil, allowMethods: [String]? = nil, allowOrigins: [String]? = nil, exposeHeaders: [String]? = nil, maxAge: Int? = nil) {
            self.allowCredentials = allowCredentials
            self.allowHeaders = allowHeaders
            self.allowMethods = allowMethods
            self.allowOrigins = allowOrigins
            self.exposeHeaders = exposeHeaders
            self.maxAge = maxAge
        }

        public func validate(name: String) throws {
            try self.allowHeaders?.forEach {
                try validate($0, name: "allowHeaders[]", parent: name, max: 1024)
                try validate($0, name: "allowHeaders[]", parent: name, pattern: ".*")
            }
            try self.validate(self.allowHeaders, name: "allowHeaders", parent: name, max: 100)
            try self.allowMethods?.forEach {
                try validate($0, name: "allowMethods[]", parent: name, max: 6)
                try validate($0, name: "allowMethods[]", parent: name, pattern: ".*")
            }
            try self.validate(self.allowMethods, name: "allowMethods", parent: name, max: 6)
            try self.allowOrigins?.forEach {
                try validate($0, name: "allowOrigins[]", parent: name, max: 253)
                try validate($0, name: "allowOrigins[]", parent: name, min: 1)
                try validate($0, name: "allowOrigins[]", parent: name, pattern: ".*")
            }
            try self.validate(self.allowOrigins, name: "allowOrigins", parent: name, max: 100)
            try self.exposeHeaders?.forEach {
                try validate($0, name: "exposeHeaders[]", parent: name, max: 1024)
                try validate($0, name: "exposeHeaders[]", parent: name, pattern: ".*")
            }
            try self.validate(self.exposeHeaders, name: "exposeHeaders", parent: name, max: 100)
            try self.validate(self.maxAge, name: "maxAge", parent: name, max: 86400)
            try self.validate(self.maxAge, name: "maxAge", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case allowCredentials = "AllowCredentials"
            case allowHeaders = "AllowHeaders"
            case allowMethods = "AllowMethods"
            case allowOrigins = "AllowOrigins"
            case exposeHeaders = "ExposeHeaders"
            case maxAge = "MaxAge"
        }
    }

    public struct CreateAliasRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// A description of the alias.
        public let description: String?
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The function version that the alias invokes.
        public let functionVersion: String
        /// The name of the alias.
        public let name: String
        /// The routing configuration of the alias.
        public let routingConfig: AliasRoutingConfiguration?

        public init(description: String? = nil, functionName: String, functionVersion: String, name: String, routingConfig: AliasRoutingConfiguration? = nil) {
            self.description = description
            self.functionName = functionName
            self.functionVersion = functionVersion
            self.name = name
            self.routingConfig = routingConfig
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, max: 1024)
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, min: 1)
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, pattern: "^(\\$LATEST|[0-9]+)$")
            try self.validate(self.name, name: "name", parent: name, max: 128)
            try self.validate(self.name, name: "name", parent: name, min: 1)
            try self.validate(self.name, name: "name", parent: name, pattern: "^(?!^[0-9]+$)([a-zA-Z0-9-_]+)$")
            try self.routingConfig?.validate(name: "\(name).routingConfig")
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case functionVersion = "FunctionVersion"
            case name = "Name"
            case routingConfig = "RoutingConfig"
        }
    }

    public struct CreateCodeSigningConfigRequest: AWSEncodableShape {
        /// Signing profiles for this code signing configuration.
        public let allowedPublishers: AllowedPublishers
        /// The code signing policies define the actions to take if the validation checks fail.
        public let codeSigningPolicies: CodeSigningPolicies?
        /// Descriptive name for this code signing configuration.
        public let description: String?

        public init(allowedPublishers: AllowedPublishers, codeSigningPolicies: CodeSigningPolicies? = nil, description: String? = nil) {
            self.allowedPublishers = allowedPublishers
            self.codeSigningPolicies = codeSigningPolicies
            self.description = description
        }

        public func validate(name: String) throws {
            try self.allowedPublishers.validate(name: "\(name).allowedPublishers")
            try self.validate(self.description, name: "description", parent: name, max: 256)
        }

        private enum CodingKeys: String, CodingKey {
            case allowedPublishers = "AllowedPublishers"
            case codeSigningPolicies = "CodeSigningPolicies"
            case description = "Description"
        }
    }

    public struct CreateCodeSigningConfigResponse: AWSDecodableShape {
        /// The code signing configuration.
        public let codeSigningConfig: CodeSigningConfig

        public init(codeSigningConfig: CodeSigningConfig) {
            self.codeSigningConfig = codeSigningConfig
        }

        private enum CodingKeys: String, CodingKey {
            case codeSigningConfig = "CodeSigningConfig"
        }
    }

    public struct CreateEventSourceMappingRequest: AWSEncodableShape {
        /// Specific configuration settings for an Amazon Managed Streaming for Apache Kafka (Amazon MSK) event source.
        public let amazonManagedKafkaEventSourceConfig: AmazonManagedKafkaEventSourceConfig?
        /// The maximum number of records in each batch that Lambda pulls from your stream or queue and sends to your function. Lambda passes all of the records in the batch to the function in a single call, up to the payload limit for synchronous invocation (6 MB).    Amazon Kinesis - Default 100. Max 10,000.    Amazon DynamoDB Streams - Default 100. Max 10,000.    Amazon Simple Queue Service - Default 10. For standard queues the max is 10,000. For FIFO queues the max is 10.    Amazon Managed Streaming for Apache Kafka - Default 100. Max 10,000.    Self-managed Apache Kafka - Default 100. Max 10,000.    Amazon MQ (ActiveMQ and RabbitMQ) - Default 100. Max 10,000.
        public let batchSize: Int?
        /// (Streams only) If the function returns an error, split the batch in two and retry.
        public let bisectBatchOnFunctionError: Bool?
        /// (Streams only) An Amazon SQS queue or Amazon SNS topic destination for discarded records.
        public let destinationConfig: DestinationConfig?
        /// When true, the event source mapping is active. When false, Lambda pauses polling and invocation. Default: True
        public let enabled: Bool?
        /// The Amazon Resource Name (ARN) of the event source.    Amazon Kinesis - The ARN of the data stream or a stream consumer.    Amazon DynamoDB Streams - The ARN of the stream.    Amazon Simple Queue Service - The ARN of the queue.    Amazon Managed Streaming for Apache Kafka - The ARN of the cluster.    Amazon MQ - The ARN of the broker.
        public let eventSourceArn: String?
        /// An object that defines the filter criteria that determine whether Lambda should process an event. For more information, see Lambda event filtering.
        public let filterCriteria: FilterCriteria?
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Version or Alias ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it's limited to 64 characters in length.
        public let functionName: String
        /// (Streams and Amazon SQS) A list of current response type enums applied to the event source mapping.
        public let functionResponseTypes: [FunctionResponseType]?
        /// The maximum amount of time, in seconds, that Lambda spends gathering records before invoking the function. You can configure MaximumBatchingWindowInSeconds to any value from 0 seconds to 300 seconds in increments of seconds. For streams and Amazon SQS event sources, the default batching window is 0 seconds. For Amazon MSK, Self-managed Apache Kafka, and Amazon MQ event sources, the default batching window is 500 ms. Note that because you can only change MaximumBatchingWindowInSeconds in increments of seconds, you cannot revert back to the 500 ms default batching window after you have changed it. To restore the default batching window, you must create a new event source mapping. Related setting: For streams and Amazon SQS event sources, when you set BatchSize to a value greater than 10, you must set MaximumBatchingWindowInSeconds to at least 1.
        public let maximumBatchingWindowInSeconds: Int?
        /// (Streams only) Discard records older than the specified age. The default value is infinite (-1).
        public let maximumRecordAgeInSeconds: Int?
        /// (Streams only) Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires.
        public let maximumRetryAttempts: Int?
        /// (Streams only) The number of batches to process from each shard concurrently.
        public let parallelizationFactor: Int?
        ///  (MQ) The name of the Amazon MQ broker destination queue to consume.
        public let queues: [String]?
        /// The self-managed Apache Kafka cluster to receive records from.
        public let selfManagedEventSource: SelfManagedEventSource?
        /// Specific configuration settings for a self-managed Apache Kafka event source.
        public let selfManagedKafkaEventSourceConfig: SelfManagedKafkaEventSourceConfig?
        /// An array of authentication protocols or VPC components required to secure your event source.
        public let sourceAccessConfigurations: [SourceAccessConfiguration]?
        /// The position in a stream from which to start reading. Required for Amazon Kinesis, Amazon DynamoDB, and Amazon MSK Streams sources. AT_TIMESTAMP is supported only for Amazon Kinesis streams.
        public let startingPosition: EventSourcePosition?
        /// With StartingPosition set to AT_TIMESTAMP, the time from which to start reading.
        public let startingPositionTimestamp: Date?
        /// The name of the Kafka topic.
        public let topics: [String]?
        /// (Streams only) The duration in seconds of a processing window. The range is between 1 second and 900 seconds.
        public let tumblingWindowInSeconds: Int?

        public init(amazonManagedKafkaEventSourceConfig: AmazonManagedKafkaEventSourceConfig? = nil, batchSize: Int? = nil, bisectBatchOnFunctionError: Bool? = nil, destinationConfig: DestinationConfig? = nil, enabled: Bool? = nil, eventSourceArn: String? = nil, filterCriteria: FilterCriteria? = nil, functionName: String, functionResponseTypes: [FunctionResponseType]? = nil, maximumBatchingWindowInSeconds: Int? = nil, maximumRecordAgeInSeconds: Int? = nil, maximumRetryAttempts: Int? = nil, parallelizationFactor: Int? = nil, queues: [String]? = nil, selfManagedEventSource: SelfManagedEventSource? = nil, selfManagedKafkaEventSourceConfig: SelfManagedKafkaEventSourceConfig? = nil, sourceAccessConfigurations: [SourceAccessConfiguration]? = nil, startingPosition: EventSourcePosition? = nil, startingPositionTimestamp: Date? = nil, topics: [String]? = nil, tumblingWindowInSeconds: Int? = nil) {
            self.amazonManagedKafkaEventSourceConfig = amazonManagedKafkaEventSourceConfig
            self.batchSize = batchSize
            self.bisectBatchOnFunctionError = bisectBatchOnFunctionError
            self.destinationConfig = destinationConfig
            self.enabled = enabled
            self.eventSourceArn = eventSourceArn
            self.filterCriteria = filterCriteria
            self.functionName = functionName
            self.functionResponseTypes = functionResponseTypes
            self.maximumBatchingWindowInSeconds = maximumBatchingWindowInSeconds
            self.maximumRecordAgeInSeconds = maximumRecordAgeInSeconds
            self.maximumRetryAttempts = maximumRetryAttempts
            self.parallelizationFactor = parallelizationFactor
            self.queues = queues
            self.selfManagedEventSource = selfManagedEventSource
            self.selfManagedKafkaEventSourceConfig = selfManagedKafkaEventSourceConfig
            self.sourceAccessConfigurations = sourceAccessConfigurations
            self.startingPosition = startingPosition
            self.startingPositionTimestamp = startingPositionTimestamp
            self.topics = topics
            self.tumblingWindowInSeconds = tumblingWindowInSeconds
        }

        public func validate(name: String) throws {
            try self.amazonManagedKafkaEventSourceConfig?.validate(name: "\(name).amazonManagedKafkaEventSourceConfig")
            try self.validate(self.batchSize, name: "batchSize", parent: name, max: 10000)
            try self.validate(self.batchSize, name: "batchSize", parent: name, min: 1)
            try self.destinationConfig?.validate(name: "\(name).destinationConfig")
            try self.validate(self.eventSourceArn, name: "eventSourceArn", parent: name, pattern: "^arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\\-])+:([a-z]{2}(-gov)?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)$")
            try self.filterCriteria?.validate(name: "\(name).filterCriteria")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.functionResponseTypes, name: "functionResponseTypes", parent: name, max: 1)
            try self.validate(self.maximumBatchingWindowInSeconds, name: "maximumBatchingWindowInSeconds", parent: name, max: 300)
            try self.validate(self.maximumBatchingWindowInSeconds, name: "maximumBatchingWindowInSeconds", parent: name, min: 0)
            try self.validate(self.maximumRecordAgeInSeconds, name: "maximumRecordAgeInSeconds", parent: name, max: 604_800)
            try self.validate(self.maximumRecordAgeInSeconds, name: "maximumRecordAgeInSeconds", parent: name, min: -1)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, max: 10000)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, min: -1)
            try self.validate(self.parallelizationFactor, name: "parallelizationFactor", parent: name, max: 10)
            try self.validate(self.parallelizationFactor, name: "parallelizationFactor", parent: name, min: 1)
            try self.queues?.forEach {
                try validate($0, name: "queues[]", parent: name, max: 1000)
                try validate($0, name: "queues[]", parent: name, min: 1)
                try validate($0, name: "queues[]", parent: name, pattern: "^[\\s\\S]*$")
            }
            try self.validate(self.queues, name: "queues", parent: name, max: 1)
            try self.validate(self.queues, name: "queues", parent: name, min: 1)
            try self.selfManagedEventSource?.validate(name: "\(name).selfManagedEventSource")
            try self.selfManagedKafkaEventSourceConfig?.validate(name: "\(name).selfManagedKafkaEventSourceConfig")
            try self.sourceAccessConfigurations?.forEach {
                try $0.validate(name: "\(name).sourceAccessConfigurations[]")
            }
            try self.validate(self.sourceAccessConfigurations, name: "sourceAccessConfigurations", parent: name, max: 22)
            try self.topics?.forEach {
                try validate($0, name: "topics[]", parent: name, max: 249)
                try validate($0, name: "topics[]", parent: name, min: 1)
                try validate($0, name: "topics[]", parent: name, pattern: "^[^.]([a-zA-Z0-9\\-_.]+)$")
            }
            try self.validate(self.topics, name: "topics", parent: name, max: 1)
            try self.validate(self.topics, name: "topics", parent: name, min: 1)
            try self.validate(self.tumblingWindowInSeconds, name: "tumblingWindowInSeconds", parent: name, max: 900)
            try self.validate(self.tumblingWindowInSeconds, name: "tumblingWindowInSeconds", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case amazonManagedKafkaEventSourceConfig = "AmazonManagedKafkaEventSourceConfig"
            case batchSize = "BatchSize"
            case bisectBatchOnFunctionError = "BisectBatchOnFunctionError"
            case destinationConfig = "DestinationConfig"
            case enabled = "Enabled"
            case eventSourceArn = "EventSourceArn"
            case filterCriteria = "FilterCriteria"
            case functionName = "FunctionName"
            case functionResponseTypes = "FunctionResponseTypes"
            case maximumBatchingWindowInSeconds = "MaximumBatchingWindowInSeconds"
            case maximumRecordAgeInSeconds = "MaximumRecordAgeInSeconds"
            case maximumRetryAttempts = "MaximumRetryAttempts"
            case parallelizationFactor = "ParallelizationFactor"
            case queues = "Queues"
            case selfManagedEventSource = "SelfManagedEventSource"
            case selfManagedKafkaEventSourceConfig = "SelfManagedKafkaEventSourceConfig"
            case sourceAccessConfigurations = "SourceAccessConfigurations"
            case startingPosition = "StartingPosition"
            case startingPositionTimestamp = "StartingPositionTimestamp"
            case topics = "Topics"
            case tumblingWindowInSeconds = "TumblingWindowInSeconds"
        }
    }

    public struct CreateFunctionRequest: AWSEncodableShape {
        /// The instruction set architecture that the function supports. Enter a string array with one of the valid values (arm64 or x86_64). The default value is x86_64.
        public let architectures: [Architecture]?
        /// The code for the function.
        public let code: FunctionCode
        /// To enable code signing for this function, specify the ARN of a code-signing configuration. A code-signing configuration
        /// includes a set of signing profiles, which define the trusted publishers for this function.
        public let codeSigningConfigArn: String?
        /// A dead-letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events when they fail processing. For more information, see Dead-letter queues.
        public let deadLetterConfig: DeadLetterConfig?
        /// A description of the function.
        public let description: String?
        /// Environment variables that are accessible from function code during execution.
        public let environment: Environment?
        /// The size of the function's /tmp directory in MB. The default value is 512, but can be any whole number between 512 and 10,240 MB.
        public let ephemeralStorage: EphemeralStorage?
        /// Connection settings for an Amazon EFS file system.
        public let fileSystemConfigs: [FileSystemConfig]?
        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The name of the method within your code that Lambda calls to run your function.
        /// Handler is required if the deployment package is a .zip file archive. The format includes the file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information, see Lambda programming model.
        public let handler: String?
        /// Container image configuration values that override the values in the container image Dockerfile.
        public let imageConfig: ImageConfig?
        /// The ARN of the Key Management Service (KMS) key that's used to encrypt your function's environment variables. If it's not provided, Lambda uses a default service key.
        public let kmsKeyArn: String?
        /// A list of function layers to add to the function's execution environment. Specify each layer by its ARN, including the version.
        public let layers: [String]?
        /// The amount of memory available to the function at runtime. Increasing the function memory also increases its CPU allocation. The default value is 128 MB. The value can be any multiple of 1 MB.
        public let memorySize: Int?
        /// The type of deployment package. Set to Image for container image and set to Zip for .zip file archive.
        public let packageType: PackageType?
        /// Set to true to publish the first version of the function during creation.
        public let publish: Bool?
        /// The Amazon Resource Name (ARN) of the function's execution role.
        public let role: String
        /// The identifier of the function's runtime. Runtime is required if the deployment package is a .zip file archive.
        public let runtime: Runtime?
        /// The function's SnapStart setting.
        public let snapStart: SnapStart?
        /// A list of tags to apply to the function.
        public let tags: [String: String]?
        /// The amount of time (in seconds) that Lambda allows a function to run before stopping it. The default is 3 seconds. The maximum allowed value is 900 seconds. For more information, see Lambda execution environment.
        public let timeout: Int?
        /// Set Mode to Active to sample and trace a subset of incoming requests with
        /// X-Ray.
        public let tracingConfig: TracingConfig?
        /// For network connectivity to Amazon Web Services resources in a VPC, specify a list of security groups and subnets in the VPC. When you connect a function to a VPC, it can access resources and the internet only through that VPC. For more information, see Configuring a Lambda function to access resources in a VPC.
        public let vpcConfig: VpcConfig?

        public init(architectures: [Architecture]? = nil, code: FunctionCode, codeSigningConfigArn: String? = nil, deadLetterConfig: DeadLetterConfig? = nil, description: String? = nil, environment: Environment? = nil, ephemeralStorage: EphemeralStorage? = nil, fileSystemConfigs: [FileSystemConfig]? = nil, functionName: String, handler: String? = nil, imageConfig: ImageConfig? = nil, kmsKeyArn: String? = nil, layers: [String]? = nil, memorySize: Int? = nil, packageType: PackageType? = nil, publish: Bool? = nil, role: String, runtime: Runtime? = nil, snapStart: SnapStart? = nil, tags: [String: String]? = nil, timeout: Int? = nil, tracingConfig: TracingConfig? = nil, vpcConfig: VpcConfig? = nil) {
            self.architectures = architectures
            self.code = code
            self.codeSigningConfigArn = codeSigningConfigArn
            self.deadLetterConfig = deadLetterConfig
            self.description = description
            self.environment = environment
            self.ephemeralStorage = ephemeralStorage
            self.fileSystemConfigs = fileSystemConfigs
            self.functionName = functionName
            self.handler = handler
            self.imageConfig = imageConfig
            self.kmsKeyArn = kmsKeyArn
            self.layers = layers
            self.memorySize = memorySize
            self.packageType = packageType
            self.publish = publish
            self.role = role
            self.runtime = runtime
            self.snapStart = snapStart
            self.tags = tags
            self.timeout = timeout
            self.tracingConfig = tracingConfig
            self.vpcConfig = vpcConfig
        }

        public func validate(name: String) throws {
            try self.validate(self.architectures, name: "architectures", parent: name, max: 1)
            try self.validate(self.architectures, name: "architectures", parent: name, min: 1)
            try self.code.validate(name: "\(name).code")
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, max: 200)
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:\\d{12}:code-signing-config:csc-[a-z0-9]{17}$")
            try self.deadLetterConfig?.validate(name: "\(name).deadLetterConfig")
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.environment?.validate(name: "\(name).environment")
            try self.ephemeralStorage?.validate(name: "\(name).ephemeralStorage")
            try self.fileSystemConfigs?.forEach {
                try $0.validate(name: "\(name).fileSystemConfigs[]")
            }
            try self.validate(self.fileSystemConfigs, name: "fileSystemConfigs", parent: name, max: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.handler, name: "handler", parent: name, max: 128)
            try self.validate(self.handler, name: "handler", parent: name, pattern: "^[^\\s]+$")
            try self.imageConfig?.validate(name: "\(name).imageConfig")
            try self.validate(self.kmsKeyArn, name: "kmsKeyArn", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()$")
            try self.layers?.forEach {
                try validate($0, name: "layers[]", parent: name, max: 140)
                try validate($0, name: "layers[]", parent: name, min: 1)
                try validate($0, name: "layers[]", parent: name, pattern: "^arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+$")
            }
            try self.validate(self.memorySize, name: "memorySize", parent: name, max: 10240)
            try self.validate(self.memorySize, name: "memorySize", parent: name, min: 128)
            try self.validate(self.role, name: "role", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+$")
            try self.validate(self.timeout, name: "timeout", parent: name, min: 1)
            try self.vpcConfig?.validate(name: "\(name).vpcConfig")
        }

        private enum CodingKeys: String, CodingKey {
            case architectures = "Architectures"
            case code = "Code"
            case codeSigningConfigArn = "CodeSigningConfigArn"
            case deadLetterConfig = "DeadLetterConfig"
            case description = "Description"
            case environment = "Environment"
            case ephemeralStorage = "EphemeralStorage"
            case fileSystemConfigs = "FileSystemConfigs"
            case functionName = "FunctionName"
            case handler = "Handler"
            case imageConfig = "ImageConfig"
            case kmsKeyArn = "KMSKeyArn"
            case layers = "Layers"
            case memorySize = "MemorySize"
            case packageType = "PackageType"
            case publish = "Publish"
            case role = "Role"
            case runtime = "Runtime"
            case snapStart = "SnapStart"
            case tags = "Tags"
            case timeout = "Timeout"
            case tracingConfig = "TracingConfig"
            case vpcConfig = "VpcConfig"
        }
    }

    public struct CreateFunctionUrlConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The type of authentication that your function URL uses. Set to AWS_IAM if you want to restrict access to authenticated IAM users only. Set to NONE if you want to bypass IAM authentication to create a public endpoint. For more information, see Security and auth model for Lambda function URLs.
        public let authType: FunctionUrlAuthType
        /// The cross-origin resource sharing (CORS) settings for your function URL.
        public let cors: Cors?
        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The alias name.
        public let qualifier: String?

        public init(authType: FunctionUrlAuthType, cors: Cors? = nil, functionName: String, qualifier: String? = nil) {
            self.authType = authType
            self.cors = cors
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.cors?.validate(name: "\(name).cors")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(^\\$LATEST$)|((?!^[0-9]+$)([a-zA-Z0-9-_]+))$")
        }

        private enum CodingKeys: String, CodingKey {
            case authType = "AuthType"
            case cors = "Cors"
        }
    }

    public struct CreateFunctionUrlConfigResponse: AWSDecodableShape {
        /// The type of authentication that your function URL uses. Set to AWS_IAM if you want to restrict access to authenticated IAM users only. Set to NONE if you want to bypass IAM authentication to create a public endpoint. For more information, see Security and auth model for Lambda function URLs.
        public let authType: FunctionUrlAuthType
        /// The cross-origin resource sharing (CORS) settings for your function URL.
        public let cors: Cors?
        /// When the function URL was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let creationTime: String
        /// The Amazon Resource Name (ARN) of your function.
        public let functionArn: String
        /// The HTTP URL endpoint for your function.
        public let functionUrl: String

        public init(authType: FunctionUrlAuthType, cors: Cors? = nil, creationTime: String, functionArn: String, functionUrl: String) {
            self.authType = authType
            self.cors = cors
            self.creationTime = creationTime
            self.functionArn = functionArn
            self.functionUrl = functionUrl
        }

        private enum CodingKeys: String, CodingKey {
            case authType = "AuthType"
            case cors = "Cors"
            case creationTime = "CreationTime"
            case functionArn = "FunctionArn"
            case functionUrl = "FunctionUrl"
        }
    }

    public struct DeadLetterConfig: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of an Amazon SQS queue or Amazon SNS topic.
        public let targetArn: String?

        public init(targetArn: String? = nil) {
            self.targetArn = targetArn
        }

        public func validate(name: String) throws {
            try self.validate(self.targetArn, name: "targetArn", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()$")
        }

        private enum CodingKeys: String, CodingKey {
            case targetArn = "TargetArn"
        }
    }

    public struct DeleteAliasRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "name", location: .uri("Name"))
        ]

        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The name of the alias.
        public let name: String

        public init(functionName: String, name: String) {
            self.functionName = functionName
            self.name = name
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.name, name: "name", parent: name, max: 128)
            try self.validate(self.name, name: "name", parent: name, min: 1)
            try self.validate(self.name, name: "name", parent: name, pattern: "^(?!^[0-9]+$)([a-zA-Z0-9-_]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteCodeSigningConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "codeSigningConfigArn", location: .uri("CodeSigningConfigArn"))
        ]

        /// The The Amazon Resource Name (ARN) of the code signing configuration.
        public let codeSigningConfigArn: String

        public init(codeSigningConfigArn: String) {
            self.codeSigningConfigArn = codeSigningConfigArn
        }

        public func validate(name: String) throws {
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, max: 200)
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:\\d{12}:code-signing-config:csc-[a-z0-9]{17}$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteCodeSigningConfigResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteEventSourceMappingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "uuid", location: .uri("UUID"))
        ]

        /// The identifier of the event source mapping.
        public let uuid: String

        public init(uuid: String) {
            self.uuid = uuid
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteFunctionCodeSigningConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String

        public init(functionName: String) {
            self.functionName = functionName
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteFunctionConcurrencyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String

        public init(functionName: String) {
            self.functionName = functionName
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteFunctionEventInvokeConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function, version, or alias.  Name formats     Function name - my-function (name-only), my-function:v1 (with alias).    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN - 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// A version number or alias name.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteFunctionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function or version.  Name formats     Function name – my-function (name-only), my-function:1 (with version).    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify a version to delete. You can't delete a version that an alias references.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteFunctionUrlConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The alias name.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(^\\$LATEST$)|((?!^[0-9]+$)([a-zA-Z0-9-_]+))$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteLayerVersionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "layerName", location: .uri("LayerName")),
            AWSMemberEncoding(label: "versionNumber", location: .uri("VersionNumber"))
        ]

        /// The name or Amazon Resource Name (ARN) of the layer.
        public let layerName: String
        /// The version number.
        public let versionNumber: Int64

        public init(layerName: String, versionNumber: Int64 = 0) {
            self.layerName = layerName
            self.versionNumber = versionNumber
        }

        public func validate(name: String) throws {
            try self.validate(self.layerName, name: "layerName", parent: name, max: 140)
            try self.validate(self.layerName, name: "layerName", parent: name, min: 1)
            try self.validate(self.layerName, name: "layerName", parent: name, pattern: "^(arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+)|[a-zA-Z0-9-_]+$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteProvisionedConcurrencyConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The version number or alias name.
        public let qualifier: String

        public init(functionName: String, qualifier: String) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DestinationConfig: AWSEncodableShape & AWSDecodableShape {
        /// The destination configuration for failed invocations.
        public let onFailure: OnFailure?
        /// The destination configuration for successful invocations.
        public let onSuccess: OnSuccess?

        public init(onFailure: OnFailure? = nil, onSuccess: OnSuccess? = nil) {
            self.onFailure = onFailure
            self.onSuccess = onSuccess
        }

        public func validate(name: String) throws {
            try self.onFailure?.validate(name: "\(name).onFailure")
            try self.onSuccess?.validate(name: "\(name).onSuccess")
        }

        private enum CodingKeys: String, CodingKey {
            case onFailure = "OnFailure"
            case onSuccess = "OnSuccess"
        }
    }

    public struct Environment: AWSEncodableShape {
        /// Environment variable key-value pairs. For more information, see Using Lambda environment variables.
        public let variables: [String: String]?

        public init(variables: [String: String]? = nil) {
            self.variables = variables
        }

        public func validate(name: String) throws {
            try self.variables?.forEach {
                try validate($0.key, name: "variables.key", parent: name, pattern: "^[a-zA-Z]([a-zA-Z0-9_])+$")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case variables = "Variables"
        }
    }

    public struct EnvironmentError: AWSDecodableShape {
        /// The error code.
        public let errorCode: String?
        /// The error message.
        public let message: String?

        public init(errorCode: String? = nil, message: String? = nil) {
            self.errorCode = errorCode
            self.message = message
        }

        private enum CodingKeys: String, CodingKey {
            case errorCode = "ErrorCode"
            case message = "Message"
        }
    }

    public struct EnvironmentResponse: AWSDecodableShape {
        /// Error messages for environment variables that couldn't be applied.
        public let error: EnvironmentError?
        /// Environment variable key-value pairs. Omitted from CloudTrail logs.
        public let variables: [String: String]?

        public init(error: EnvironmentError? = nil, variables: [String: String]? = nil) {
            self.error = error
            self.variables = variables
        }

        private enum CodingKeys: String, CodingKey {
            case error = "Error"
            case variables = "Variables"
        }
    }

    public struct EphemeralStorage: AWSEncodableShape & AWSDecodableShape {
        /// The size of the function's /tmp directory.
        public let size: Int

        public init(size: Int) {
            self.size = size
        }

        public func validate(name: String) throws {
            try self.validate(self.size, name: "size", parent: name, max: 10240)
            try self.validate(self.size, name: "size", parent: name, min: 512)
        }

        private enum CodingKeys: String, CodingKey {
            case size = "Size"
        }
    }

    public struct EventSourceMappingConfiguration: AWSDecodableShape {
        /// Specific configuration settings for an Amazon Managed Streaming for Apache Kafka (Amazon MSK) event source.
        public let amazonManagedKafkaEventSourceConfig: AmazonManagedKafkaEventSourceConfig?
        /// The maximum number of records in each batch that Lambda pulls from your stream or queue and sends to your function. Lambda passes all of the records in the batch to the function in a single call, up to the payload limit for synchronous invocation (6 MB). Default value: Varies by service. For Amazon SQS, the default is 10. For all other services, the default is 100. Related setting: When you set BatchSize to a value greater than 10, you must set MaximumBatchingWindowInSeconds to at least 1.
        public let batchSize: Int?
        /// (Streams only) If the function returns an error, split the batch in two and retry. The default value is false.
        public let bisectBatchOnFunctionError: Bool?
        /// (Streams only) An Amazon SQS queue or Amazon SNS topic destination for discarded records.
        public let destinationConfig: DestinationConfig?
        /// The Amazon Resource Name (ARN) of the event source.
        public let eventSourceArn: String?
        /// An object that defines the filter criteria that determine whether Lambda should process an event. For more information, see Lambda event filtering.
        public let filterCriteria: FilterCriteria?
        /// The ARN of the Lambda function.
        public let functionArn: String?
        /// (Streams and Amazon SQS) A list of current response type enums applied to the event source mapping.
        public let functionResponseTypes: [FunctionResponseType]?
        /// The date that the event source mapping was last updated or that its state changed.
        public let lastModified: Date?
        /// The result of the last Lambda invocation of your function.
        public let lastProcessingResult: String?
        /// The maximum amount of time, in seconds, that Lambda spends gathering records before invoking the function. You can configure MaximumBatchingWindowInSeconds to any value from 0 seconds to 300 seconds in increments of seconds. For streams and Amazon SQS event sources, the default batching window is 0 seconds. For Amazon MSK, Self-managed Apache Kafka, and Amazon MQ event sources, the default batching window is 500 ms. Note that because you can only change MaximumBatchingWindowInSeconds in increments of seconds, you cannot revert back to the 500 ms default batching window after you have changed it. To restore the default batching window, you must create a new event source mapping. Related setting: For streams and Amazon SQS event sources, when you set BatchSize to a value greater than 10, you must set MaximumBatchingWindowInSeconds to at least 1.
        public let maximumBatchingWindowInSeconds: Int?
        /// (Streams only) Discard records older than the specified age. The default value is -1,
        /// which sets the maximum age to infinite. When the value is set to infinite, Lambda never discards old records.
        public let maximumRecordAgeInSeconds: Int?
        /// (Streams only) Discard records after the specified number of retries. The default value is -1,
        /// which sets the maximum number of retries to infinite. When MaximumRetryAttempts is infinite, Lambda retries failed records until the record expires in the event source.
        public let maximumRetryAttempts: Int?
        /// (Streams only) The number of batches to process concurrently from each shard. The default value is 1.
        public let parallelizationFactor: Int?
        ///  (Amazon MQ) The name of the Amazon MQ broker destination queue to consume.
        public let queues: [String]?
        /// The self-managed Apache Kafka cluster for your event source.
        public let selfManagedEventSource: SelfManagedEventSource?
        /// Specific configuration settings for a self-managed Apache Kafka event source.
        public let selfManagedKafkaEventSourceConfig: SelfManagedKafkaEventSourceConfig?
        /// An array of the authentication protocol, VPC components, or virtual host to secure and define your event source.
        public let sourceAccessConfigurations: [SourceAccessConfiguration]?
        /// The position in a stream from which to start reading. Required for Amazon Kinesis, Amazon DynamoDB, and Amazon MSK stream sources. AT_TIMESTAMP is supported only for Amazon Kinesis streams.
        public let startingPosition: EventSourcePosition?
        /// With StartingPosition set to AT_TIMESTAMP, the time from which to start reading.
        public let startingPositionTimestamp: Date?
        /// The state of the event source mapping. It can be one of the following: Creating, Enabling, Enabled, Disabling, Disabled, Updating, or Deleting.
        public let state: String?
        /// Indicates whether a user or Lambda made the last change to the event source mapping.
        public let stateTransitionReason: String?
        /// The name of the Kafka topic.
        public let topics: [String]?
        /// (Streams only) The duration in seconds of a processing window. The range is 1–900 seconds.
        public let tumblingWindowInSeconds: Int?
        /// The identifier of the event source mapping.
        public let uuid: String?

        public init(amazonManagedKafkaEventSourceConfig: AmazonManagedKafkaEventSourceConfig? = nil, batchSize: Int? = nil, bisectBatchOnFunctionError: Bool? = nil, destinationConfig: DestinationConfig? = nil, eventSourceArn: String? = nil, filterCriteria: FilterCriteria? = nil, functionArn: String? = nil, functionResponseTypes: [FunctionResponseType]? = nil, lastModified: Date? = nil, lastProcessingResult: String? = nil, maximumBatchingWindowInSeconds: Int? = nil, maximumRecordAgeInSeconds: Int? = nil, maximumRetryAttempts: Int? = nil, parallelizationFactor: Int? = nil, queues: [String]? = nil, selfManagedEventSource: SelfManagedEventSource? = nil, selfManagedKafkaEventSourceConfig: SelfManagedKafkaEventSourceConfig? = nil, sourceAccessConfigurations: [SourceAccessConfiguration]? = nil, startingPosition: EventSourcePosition? = nil, startingPositionTimestamp: Date? = nil, state: String? = nil, stateTransitionReason: String? = nil, topics: [String]? = nil, tumblingWindowInSeconds: Int? = nil, uuid: String? = nil) {
            self.amazonManagedKafkaEventSourceConfig = amazonManagedKafkaEventSourceConfig
            self.batchSize = batchSize
            self.bisectBatchOnFunctionError = bisectBatchOnFunctionError
            self.destinationConfig = destinationConfig
            self.eventSourceArn = eventSourceArn
            self.filterCriteria = filterCriteria
            self.functionArn = functionArn
            self.functionResponseTypes = functionResponseTypes
            self.lastModified = lastModified
            self.lastProcessingResult = lastProcessingResult
            self.maximumBatchingWindowInSeconds = maximumBatchingWindowInSeconds
            self.maximumRecordAgeInSeconds = maximumRecordAgeInSeconds
            self.maximumRetryAttempts = maximumRetryAttempts
            self.parallelizationFactor = parallelizationFactor
            self.queues = queues
            self.selfManagedEventSource = selfManagedEventSource
            self.selfManagedKafkaEventSourceConfig = selfManagedKafkaEventSourceConfig
            self.sourceAccessConfigurations = sourceAccessConfigurations
            self.startingPosition = startingPosition
            self.startingPositionTimestamp = startingPositionTimestamp
            self.state = state
            self.stateTransitionReason = stateTransitionReason
            self.topics = topics
            self.tumblingWindowInSeconds = tumblingWindowInSeconds
            self.uuid = uuid
        }

        private enum CodingKeys: String, CodingKey {
            case amazonManagedKafkaEventSourceConfig = "AmazonManagedKafkaEventSourceConfig"
            case batchSize = "BatchSize"
            case bisectBatchOnFunctionError = "BisectBatchOnFunctionError"
            case destinationConfig = "DestinationConfig"
            case eventSourceArn = "EventSourceArn"
            case filterCriteria = "FilterCriteria"
            case functionArn = "FunctionArn"
            case functionResponseTypes = "FunctionResponseTypes"
            case lastModified = "LastModified"
            case lastProcessingResult = "LastProcessingResult"
            case maximumBatchingWindowInSeconds = "MaximumBatchingWindowInSeconds"
            case maximumRecordAgeInSeconds = "MaximumRecordAgeInSeconds"
            case maximumRetryAttempts = "MaximumRetryAttempts"
            case parallelizationFactor = "ParallelizationFactor"
            case queues = "Queues"
            case selfManagedEventSource = "SelfManagedEventSource"
            case selfManagedKafkaEventSourceConfig = "SelfManagedKafkaEventSourceConfig"
            case sourceAccessConfigurations = "SourceAccessConfigurations"
            case startingPosition = "StartingPosition"
            case startingPositionTimestamp = "StartingPositionTimestamp"
            case state = "State"
            case stateTransitionReason = "StateTransitionReason"
            case topics = "Topics"
            case tumblingWindowInSeconds = "TumblingWindowInSeconds"
            case uuid = "UUID"
        }
    }

    public struct FileSystemConfig: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the Amazon EFS access point that provides access to the file system.
        public let arn: String
        /// The path where the function can access the file system, starting with /mnt/.
        public let localMountPath: String

        public init(arn: String, localMountPath: String) {
            self.arn = arn
            self.localMountPath = localMountPath
        }

        public func validate(name: String) throws {
            try self.validate(self.arn, name: "arn", parent: name, max: 200)
            try self.validate(self.arn, name: "arn", parent: name, pattern: "^arn:aws[a-zA-Z-]*:elasticfilesystem:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:\\d{12}:access-point/fsap-[a-f0-9]{17}$")
            try self.validate(self.localMountPath, name: "localMountPath", parent: name, max: 160)
            try self.validate(self.localMountPath, name: "localMountPath", parent: name, pattern: "^/mnt/[a-zA-Z0-9-_.]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case arn = "Arn"
            case localMountPath = "LocalMountPath"
        }
    }

    public struct Filter: AWSEncodableShape & AWSDecodableShape {
        ///  A filter pattern. For more information on the syntax of a filter pattern, see  Filter rule syntax.
        public let pattern: String?

        public init(pattern: String? = nil) {
            self.pattern = pattern
        }

        public func validate(name: String) throws {
            try self.validate(self.pattern, name: "pattern", parent: name, max: 4096)
            try self.validate(self.pattern, name: "pattern", parent: name, pattern: ".*")
        }

        private enum CodingKeys: String, CodingKey {
            case pattern = "Pattern"
        }
    }

    public struct FilterCriteria: AWSEncodableShape & AWSDecodableShape {
        ///  A list of filters.
        public let filters: [Filter]?

        public init(filters: [Filter]? = nil) {
            self.filters = filters
        }

        public func validate(name: String) throws {
            try self.filters?.forEach {
                try $0.validate(name: "\(name).filters[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case filters = "Filters"
        }
    }

    public struct FunctionCode: AWSEncodableShape {
        /// URI of a container image in the Amazon ECR registry.
        public let imageUri: String?
        /// An Amazon S3 bucket in the same Amazon Web Services Region as your function. The bucket can be in a different Amazon Web Services account.
        public let s3Bucket: String?
        /// The Amazon S3 key of the deployment package.
        public let s3Key: String?
        /// For versioned objects, the version of the deployment package object to use.
        public let s3ObjectVersion: String?
        /// The base64-encoded contents of the deployment package. Amazon Web Services SDK and CLI clients handle the encoding for you.
        public let zipFile: AWSBase64Data?

        public init(imageUri: String? = nil, s3Bucket: String? = nil, s3Key: String? = nil, s3ObjectVersion: String? = nil, zipFile: AWSBase64Data? = nil) {
            self.imageUri = imageUri
            self.s3Bucket = s3Bucket
            self.s3Key = s3Key
            self.s3ObjectVersion = s3ObjectVersion
            self.zipFile = zipFile
        }

        public func validate(name: String) throws {
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, max: 63)
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, min: 3)
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, pattern: "^[0-9A-Za-z\\.\\-_]*(?<!\\.)$")
            try self.validate(self.s3Key, name: "s3Key", parent: name, max: 1024)
            try self.validate(self.s3Key, name: "s3Key", parent: name, min: 1)
            try self.validate(self.s3ObjectVersion, name: "s3ObjectVersion", parent: name, max: 1024)
            try self.validate(self.s3ObjectVersion, name: "s3ObjectVersion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case imageUri = "ImageUri"
            case s3Bucket = "S3Bucket"
            case s3Key = "S3Key"
            case s3ObjectVersion = "S3ObjectVersion"
            case zipFile = "ZipFile"
        }
    }

    public struct FunctionCodeLocation: AWSDecodableShape {
        /// URI of a container image in the Amazon ECR registry.
        public let imageUri: String?
        /// A presigned URL that you can use to download the deployment package.
        public let location: String?
        /// The service that's hosting the file.
        public let repositoryType: String?
        /// The resolved URI for the image.
        public let resolvedImageUri: String?

        public init(imageUri: String? = nil, location: String? = nil, repositoryType: String? = nil, resolvedImageUri: String? = nil) {
            self.imageUri = imageUri
            self.location = location
            self.repositoryType = repositoryType
            self.resolvedImageUri = resolvedImageUri
        }

        private enum CodingKeys: String, CodingKey {
            case imageUri = "ImageUri"
            case location = "Location"
            case repositoryType = "RepositoryType"
            case resolvedImageUri = "ResolvedImageUri"
        }
    }

    public struct FunctionConfiguration: AWSDecodableShape {
        /// The instruction set architecture that the function supports. Architecture is a string array with one of the  valid values. The default architecture value is x86_64.
        public let architectures: [Architecture]?
        /// The SHA256 hash of the function's deployment package.
        public let codeSha256: String?
        /// The size of the function's deployment package, in bytes.
        public let codeSize: Int64?
        /// The function's dead letter queue.
        public let deadLetterConfig: DeadLetterConfig?
        /// The function's description.
        public let description: String?
        /// The function's environment variables. Omitted from CloudTrail logs.
        public let environment: EnvironmentResponse?
        /// The size of the function’s /tmp directory in MB. The default value is 512, but it can be any whole number between 512 and 10,240 MB.
        public let ephemeralStorage: EphemeralStorage?
        /// Connection settings for an Amazon EFS file system.
        public let fileSystemConfigs: [FileSystemConfig]?
        /// The function's Amazon Resource Name (ARN).
        public let functionArn: String?
        /// The name of the function.
        public let functionName: String?
        /// The function that Lambda calls to begin running your function.
        public let handler: String?
        /// The function's image configuration values.
        public let imageConfigResponse: ImageConfigResponse?
        /// The KMS key that's used to encrypt the function's environment variables. This key is returned only if you've configured a customer managed key.
        public let kmsKeyArn: String?
        /// The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let lastModified: String?
        /// The status of the last update that was performed on the function. This is first set to Successful after function creation completes.
        public let lastUpdateStatus: LastUpdateStatus?
        /// The reason for the last update that was performed on the function.
        public let lastUpdateStatusReason: String?
        /// The reason code for the last update that was performed on the function.
        public let lastUpdateStatusReasonCode: LastUpdateStatusReasonCode?
        /// The function's layers.
        public let layers: [Layer]?
        /// For Lambda@Edge functions, the ARN of the main function.
        public let masterArn: String?
        /// The amount of memory available to the function at runtime.
        public let memorySize: Int?
        /// The type of deployment package. Set to Image for container image and set Zip for .zip file archive.
        public let packageType: PackageType?
        /// The latest updated revision of the function or alias.
        public let revisionId: String?
        /// The function's execution role.
        public let role: String?
        /// The runtime environment for the Lambda function.
        public let runtime: Runtime?
        /// The ARN of the signing job.
        public let signingJobArn: String?
        /// The ARN of the signing profile version.
        public let signingProfileVersionArn: String?
        /// Set ApplyOn to PublishedVersions to create a snapshot of the initialized execution environment when you publish a function version. For more information, see Reducing startup time with Lambda SnapStart.
        public let snapStart: SnapStartResponse?
        /// The current state of the function. When the state is Inactive, you can reactivate the function by invoking it.
        public let state: State?
        /// The reason for the function's current state.
        public let stateReason: String?
        /// The reason code for the function's current state. When the code is Creating, you can't invoke or modify the function.
        public let stateReasonCode: StateReasonCode?
        /// The amount of time in seconds that Lambda allows a function to run before stopping it.
        public let timeout: Int?
        /// The function's X-Ray tracing configuration.
        public let tracingConfig: TracingConfigResponse?
        /// The version of the Lambda function.
        public let version: String?
        /// The function's networking configuration.
        public let vpcConfig: VpcConfigResponse?

        public init(architectures: [Architecture]? = nil, codeSha256: String? = nil, codeSize: Int64? = nil, deadLetterConfig: DeadLetterConfig? = nil, description: String? = nil, environment: EnvironmentResponse? = nil, ephemeralStorage: EphemeralStorage? = nil, fileSystemConfigs: [FileSystemConfig]? = nil, functionArn: String? = nil, functionName: String? = nil, handler: String? = nil, imageConfigResponse: ImageConfigResponse? = nil, kmsKeyArn: String? = nil, lastModified: String? = nil, lastUpdateStatus: LastUpdateStatus? = nil, lastUpdateStatusReason: String? = nil, lastUpdateStatusReasonCode: LastUpdateStatusReasonCode? = nil, layers: [Layer]? = nil, masterArn: String? = nil, memorySize: Int? = nil, packageType: PackageType? = nil, revisionId: String? = nil, role: String? = nil, runtime: Runtime? = nil, signingJobArn: String? = nil, signingProfileVersionArn: String? = nil, snapStart: SnapStartResponse? = nil, state: State? = nil, stateReason: String? = nil, stateReasonCode: StateReasonCode? = nil, timeout: Int? = nil, tracingConfig: TracingConfigResponse? = nil, version: String? = nil, vpcConfig: VpcConfigResponse? = nil) {
            self.architectures = architectures
            self.codeSha256 = codeSha256
            self.codeSize = codeSize
            self.deadLetterConfig = deadLetterConfig
            self.description = description
            self.environment = environment
            self.ephemeralStorage = ephemeralStorage
            self.fileSystemConfigs = fileSystemConfigs
            self.functionArn = functionArn
            self.functionName = functionName
            self.handler = handler
            self.imageConfigResponse = imageConfigResponse
            self.kmsKeyArn = kmsKeyArn
            self.lastModified = lastModified
            self.lastUpdateStatus = lastUpdateStatus
            self.lastUpdateStatusReason = lastUpdateStatusReason
            self.lastUpdateStatusReasonCode = lastUpdateStatusReasonCode
            self.layers = layers
            self.masterArn = masterArn
            self.memorySize = memorySize
            self.packageType = packageType
            self.revisionId = revisionId
            self.role = role
            self.runtime = runtime
            self.signingJobArn = signingJobArn
            self.signingProfileVersionArn = signingProfileVersionArn
            self.snapStart = snapStart
            self.state = state
            self.stateReason = stateReason
            self.stateReasonCode = stateReasonCode
            self.timeout = timeout
            self.tracingConfig = tracingConfig
            self.version = version
            self.vpcConfig = vpcConfig
        }

        private enum CodingKeys: String, CodingKey {
            case architectures = "Architectures"
            case codeSha256 = "CodeSha256"
            case codeSize = "CodeSize"
            case deadLetterConfig = "DeadLetterConfig"
            case description = "Description"
            case environment = "Environment"
            case ephemeralStorage = "EphemeralStorage"
            case fileSystemConfigs = "FileSystemConfigs"
            case functionArn = "FunctionArn"
            case functionName = "FunctionName"
            case handler = "Handler"
            case imageConfigResponse = "ImageConfigResponse"
            case kmsKeyArn = "KMSKeyArn"
            case lastModified = "LastModified"
            case lastUpdateStatus = "LastUpdateStatus"
            case lastUpdateStatusReason = "LastUpdateStatusReason"
            case lastUpdateStatusReasonCode = "LastUpdateStatusReasonCode"
            case layers = "Layers"
            case masterArn = "MasterArn"
            case memorySize = "MemorySize"
            case packageType = "PackageType"
            case revisionId = "RevisionId"
            case role = "Role"
            case runtime = "Runtime"
            case signingJobArn = "SigningJobArn"
            case signingProfileVersionArn = "SigningProfileVersionArn"
            case snapStart = "SnapStart"
            case state = "State"
            case stateReason = "StateReason"
            case stateReasonCode = "StateReasonCode"
            case timeout = "Timeout"
            case tracingConfig = "TracingConfig"
            case version = "Version"
            case vpcConfig = "VpcConfig"
        }
    }

    public struct FunctionEventInvokeConfig: AWSDecodableShape {
        /// A destination for events after they have been sent to a function for processing.  Destinations     Function - The Amazon Resource Name (ARN) of a Lambda function.    Queue - The ARN of an SQS queue.    Topic - The ARN of an SNS topic.    Event Bus - The ARN of an Amazon EventBridge event bus.
        public let destinationConfig: DestinationConfig?
        /// The Amazon Resource Name (ARN) of the function.
        public let functionArn: String?
        /// The date and time that the configuration was last updated.
        public let lastModified: Date?
        /// The maximum age of a request that Lambda sends to a function for processing.
        public let maximumEventAgeInSeconds: Int?
        /// The maximum number of times to retry when the function returns an error.
        public let maximumRetryAttempts: Int?

        public init(destinationConfig: DestinationConfig? = nil, functionArn: String? = nil, lastModified: Date? = nil, maximumEventAgeInSeconds: Int? = nil, maximumRetryAttempts: Int? = nil) {
            self.destinationConfig = destinationConfig
            self.functionArn = functionArn
            self.lastModified = lastModified
            self.maximumEventAgeInSeconds = maximumEventAgeInSeconds
            self.maximumRetryAttempts = maximumRetryAttempts
        }

        private enum CodingKeys: String, CodingKey {
            case destinationConfig = "DestinationConfig"
            case functionArn = "FunctionArn"
            case lastModified = "LastModified"
            case maximumEventAgeInSeconds = "MaximumEventAgeInSeconds"
            case maximumRetryAttempts = "MaximumRetryAttempts"
        }
    }

    public struct FunctionUrlConfig: AWSDecodableShape {
        /// The type of authentication that your function URL uses. Set to AWS_IAM if you want to restrict access to authenticated IAM users only. Set to NONE if you want to bypass IAM authentication to create a public endpoint. For more information, see Security and auth model for Lambda function URLs.
        public let authType: FunctionUrlAuthType
        /// The cross-origin resource sharing (CORS) settings for your function URL.
        public let cors: Cors?
        /// When the function URL was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let creationTime: String
        /// The Amazon Resource Name (ARN) of your function.
        public let functionArn: String
        /// The HTTP URL endpoint for your function.
        public let functionUrl: String
        /// When the function URL configuration was last updated, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let lastModifiedTime: String

        public init(authType: FunctionUrlAuthType, cors: Cors? = nil, creationTime: String, functionArn: String, functionUrl: String, lastModifiedTime: String) {
            self.authType = authType
            self.cors = cors
            self.creationTime = creationTime
            self.functionArn = functionArn
            self.functionUrl = functionUrl
            self.lastModifiedTime = lastModifiedTime
        }

        private enum CodingKeys: String, CodingKey {
            case authType = "AuthType"
            case cors = "Cors"
            case creationTime = "CreationTime"
            case functionArn = "FunctionArn"
            case functionUrl = "FunctionUrl"
            case lastModifiedTime = "LastModifiedTime"
        }
    }

    public struct GetAccountSettingsRequest: AWSEncodableShape {
        public init() {}
    }

    public struct GetAccountSettingsResponse: AWSDecodableShape {
        /// Limits that are related to concurrency and code storage.
        public let accountLimit: AccountLimit?
        /// The number of functions and amount of storage in use.
        public let accountUsage: AccountUsage?

        public init(accountLimit: AccountLimit? = nil, accountUsage: AccountUsage? = nil) {
            self.accountLimit = accountLimit
            self.accountUsage = accountUsage
        }

        private enum CodingKeys: String, CodingKey {
            case accountLimit = "AccountLimit"
            case accountUsage = "AccountUsage"
        }
    }

    public struct GetAliasRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "name", location: .uri("Name"))
        ]

        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The name of the alias.
        public let name: String

        public init(functionName: String, name: String) {
            self.functionName = functionName
            self.name = name
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.name, name: "name", parent: name, max: 128)
            try self.validate(self.name, name: "name", parent: name, min: 1)
            try self.validate(self.name, name: "name", parent: name, pattern: "^(?!^[0-9]+$)([a-zA-Z0-9-_]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetCodeSigningConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "codeSigningConfigArn", location: .uri("CodeSigningConfigArn"))
        ]

        /// The The Amazon Resource Name (ARN) of the code signing configuration.
        public let codeSigningConfigArn: String

        public init(codeSigningConfigArn: String) {
            self.codeSigningConfigArn = codeSigningConfigArn
        }

        public func validate(name: String) throws {
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, max: 200)
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:\\d{12}:code-signing-config:csc-[a-z0-9]{17}$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetCodeSigningConfigResponse: AWSDecodableShape {
        /// The code signing configuration
        public let codeSigningConfig: CodeSigningConfig

        public init(codeSigningConfig: CodeSigningConfig) {
            self.codeSigningConfig = codeSigningConfig
        }

        private enum CodingKeys: String, CodingKey {
            case codeSigningConfig = "CodeSigningConfig"
        }
    }

    public struct GetEventSourceMappingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "uuid", location: .uri("UUID"))
        ]

        /// The identifier of the event source mapping.
        public let uuid: String

        public init(uuid: String) {
            self.uuid = uuid
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetFunctionCodeSigningConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String

        public init(functionName: String) {
            self.functionName = functionName
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetFunctionCodeSigningConfigResponse: AWSDecodableShape {
        /// The The Amazon Resource Name (ARN) of the code signing configuration.
        public let codeSigningConfigArn: String
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String

        public init(codeSigningConfigArn: String, functionName: String) {
            self.codeSigningConfigArn = codeSigningConfigArn
            self.functionName = functionName
        }

        private enum CodingKeys: String, CodingKey {
            case codeSigningConfigArn = "CodeSigningConfigArn"
            case functionName = "FunctionName"
        }
    }

    public struct GetFunctionConcurrencyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String

        public init(functionName: String) {
            self.functionName = functionName
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetFunctionConcurrencyResponse: AWSDecodableShape {
        /// The number of simultaneous executions that are reserved for the function.
        public let reservedConcurrentExecutions: Int?

        public init(reservedConcurrentExecutions: Int? = nil) {
            self.reservedConcurrentExecutions = reservedConcurrentExecutions
        }

        private enum CodingKeys: String, CodingKey {
            case reservedConcurrentExecutions = "ReservedConcurrentExecutions"
        }
    }

    public struct GetFunctionConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function, version, or alias.  Name formats     Function name – my-function (name-only), my-function:v1 (with alias).    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify a version or alias to get details about a published version of the function.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 170)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetFunctionEventInvokeConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function, version, or alias.  Name formats     Function name - my-function (name-only), my-function:v1 (with alias).    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN - 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// A version number or alias name.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetFunctionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function, version, or alias.  Name formats     Function name – my-function (name-only), my-function:v1 (with alias).    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify a version or alias to get details about a published version of the function.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 170)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetFunctionResponse: AWSDecodableShape {
        /// The deployment package of the function or version.
        public let code: FunctionCodeLocation?
        /// The function's reserved concurrency.
        public let concurrency: Concurrency?
        /// The configuration of the function or version.
        public let configuration: FunctionConfiguration?
        /// The function's tags.
        public let tags: [String: String]?

        public init(code: FunctionCodeLocation? = nil, concurrency: Concurrency? = nil, configuration: FunctionConfiguration? = nil, tags: [String: String]? = nil) {
            self.code = code
            self.concurrency = concurrency
            self.configuration = configuration
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case code = "Code"
            case concurrency = "Concurrency"
            case configuration = "Configuration"
            case tags = "Tags"
        }
    }

    public struct GetFunctionUrlConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The alias name.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(^\\$LATEST$)|((?!^[0-9]+$)([a-zA-Z0-9-_]+))$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetFunctionUrlConfigResponse: AWSDecodableShape {
        /// The type of authentication that your function URL uses. Set to AWS_IAM if you want to restrict access to authenticated IAM users only. Set to NONE if you want to bypass IAM authentication to create a public endpoint. For more information, see Security and auth model for Lambda function URLs.
        public let authType: FunctionUrlAuthType
        /// The cross-origin resource sharing (CORS) settings for your function URL.
        public let cors: Cors?
        /// When the function URL was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let creationTime: String
        /// The Amazon Resource Name (ARN) of your function.
        public let functionArn: String
        /// The HTTP URL endpoint for your function.
        public let functionUrl: String
        /// When the function URL configuration was last updated, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let lastModifiedTime: String

        public init(authType: FunctionUrlAuthType, cors: Cors? = nil, creationTime: String, functionArn: String, functionUrl: String, lastModifiedTime: String) {
            self.authType = authType
            self.cors = cors
            self.creationTime = creationTime
            self.functionArn = functionArn
            self.functionUrl = functionUrl
            self.lastModifiedTime = lastModifiedTime
        }

        private enum CodingKeys: String, CodingKey {
            case authType = "AuthType"
            case cors = "Cors"
            case creationTime = "CreationTime"
            case functionArn = "FunctionArn"
            case functionUrl = "FunctionUrl"
            case lastModifiedTime = "LastModifiedTime"
        }
    }

    public struct GetLayerVersionByArnRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "arn", location: .querystring("Arn"))
        ]

        /// The ARN of the layer version.
        public let arn: String

        public init(arn: String) {
            self.arn = arn
        }

        public func validate(name: String) throws {
            try self.validate(self.arn, name: "arn", parent: name, max: 140)
            try self.validate(self.arn, name: "arn", parent: name, min: 1)
            try self.validate(self.arn, name: "arn", parent: name, pattern: "^arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetLayerVersionPolicyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "layerName", location: .uri("LayerName")),
            AWSMemberEncoding(label: "versionNumber", location: .uri("VersionNumber"))
        ]

        /// The name or Amazon Resource Name (ARN) of the layer.
        public let layerName: String
        /// The version number.
        public let versionNumber: Int64

        public init(layerName: String, versionNumber: Int64 = 0) {
            self.layerName = layerName
            self.versionNumber = versionNumber
        }

        public func validate(name: String) throws {
            try self.validate(self.layerName, name: "layerName", parent: name, max: 140)
            try self.validate(self.layerName, name: "layerName", parent: name, min: 1)
            try self.validate(self.layerName, name: "layerName", parent: name, pattern: "^(arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+)|[a-zA-Z0-9-_]+$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetLayerVersionPolicyResponse: AWSDecodableShape {
        /// The policy document.
        public let policy: String?
        /// A unique identifier for the current revision of the policy.
        public let revisionId: String?

        public init(policy: String? = nil, revisionId: String? = nil) {
            self.policy = policy
            self.revisionId = revisionId
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
            case revisionId = "RevisionId"
        }
    }

    public struct GetLayerVersionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "layerName", location: .uri("LayerName")),
            AWSMemberEncoding(label: "versionNumber", location: .uri("VersionNumber"))
        ]

        /// The name or Amazon Resource Name (ARN) of the layer.
        public let layerName: String
        /// The version number.
        public let versionNumber: Int64

        public init(layerName: String, versionNumber: Int64 = 0) {
            self.layerName = layerName
            self.versionNumber = versionNumber
        }

        public func validate(name: String) throws {
            try self.validate(self.layerName, name: "layerName", parent: name, max: 140)
            try self.validate(self.layerName, name: "layerName", parent: name, min: 1)
            try self.validate(self.layerName, name: "layerName", parent: name, pattern: "^(arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+)|[a-zA-Z0-9-_]+$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetLayerVersionResponse: AWSDecodableShape {
        /// A list of compatible
        /// instruction set architectures.
        public let compatibleArchitectures: [Architecture]?
        /// The layer's compatible runtimes.
        public let compatibleRuntimes: [Runtime]?
        /// Details about the layer version.
        public let content: LayerVersionContentOutput?
        /// The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let createdDate: String?
        /// The description of the version.
        public let description: String?
        /// The ARN of the layer.
        public let layerArn: String?
        /// The ARN of the layer version.
        public let layerVersionArn: String?
        /// The layer's software license.
        public let licenseInfo: String?
        /// The version number.
        public let version: Int64?

        public init(compatibleArchitectures: [Architecture]? = nil, compatibleRuntimes: [Runtime]? = nil, content: LayerVersionContentOutput? = nil, createdDate: String? = nil, description: String? = nil, layerArn: String? = nil, layerVersionArn: String? = nil, licenseInfo: String? = nil, version: Int64? = nil) {
            self.compatibleArchitectures = compatibleArchitectures
            self.compatibleRuntimes = compatibleRuntimes
            self.content = content
            self.createdDate = createdDate
            self.description = description
            self.layerArn = layerArn
            self.layerVersionArn = layerVersionArn
            self.licenseInfo = licenseInfo
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case compatibleArchitectures = "CompatibleArchitectures"
            case compatibleRuntimes = "CompatibleRuntimes"
            case content = "Content"
            case createdDate = "CreatedDate"
            case description = "Description"
            case layerArn = "LayerArn"
            case layerVersionArn = "LayerVersionArn"
            case licenseInfo = "LicenseInfo"
            case version = "Version"
        }
    }

    public struct GetPolicyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function, version, or alias.  Name formats     Function name – my-function (name-only), my-function:v1 (with alias).    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify a version or alias to get the policy for that resource.
        public let qualifier: String?

        public init(functionName: String, qualifier: String? = nil) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 170)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetPolicyResponse: AWSDecodableShape {
        /// The resource-based policy.
        public let policy: String?
        /// A unique identifier for the current revision of the policy.
        public let revisionId: String?

        public init(policy: String? = nil, revisionId: String? = nil) {
            self.policy = policy
            self.revisionId = revisionId
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
            case revisionId = "RevisionId"
        }
    }

    public struct GetProvisionedConcurrencyConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The version number or alias name.
        public let qualifier: String

        public init(functionName: String, qualifier: String) {
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetProvisionedConcurrencyConfigResponse: AWSDecodableShape {
        /// The amount of provisioned concurrency allocated. When a weighted alias is used during linear and canary deployments, this value fluctuates depending on the amount of concurrency that is provisioned for the function versions.
        public let allocatedProvisionedConcurrentExecutions: Int?
        /// The amount of provisioned concurrency available.
        public let availableProvisionedConcurrentExecutions: Int?
        /// The date and time that a user last updated the configuration, in ISO 8601 format.
        public let lastModified: String?
        /// The amount of provisioned concurrency requested.
        public let requestedProvisionedConcurrentExecutions: Int?
        /// The status of the allocation process.
        public let status: ProvisionedConcurrencyStatusEnum?
        /// For failed allocations, the reason that provisioned concurrency could not be allocated.
        public let statusReason: String?

        public init(allocatedProvisionedConcurrentExecutions: Int? = nil, availableProvisionedConcurrentExecutions: Int? = nil, lastModified: String? = nil, requestedProvisionedConcurrentExecutions: Int? = nil, status: ProvisionedConcurrencyStatusEnum? = nil, statusReason: String? = nil) {
            self.allocatedProvisionedConcurrentExecutions = allocatedProvisionedConcurrentExecutions
            self.availableProvisionedConcurrentExecutions = availableProvisionedConcurrentExecutions
            self.lastModified = lastModified
            self.requestedProvisionedConcurrentExecutions = requestedProvisionedConcurrentExecutions
            self.status = status
            self.statusReason = statusReason
        }

        private enum CodingKeys: String, CodingKey {
            case allocatedProvisionedConcurrentExecutions = "AllocatedProvisionedConcurrentExecutions"
            case availableProvisionedConcurrentExecutions = "AvailableProvisionedConcurrentExecutions"
            case lastModified = "LastModified"
            case requestedProvisionedConcurrentExecutions = "RequestedProvisionedConcurrentExecutions"
            case status = "Status"
            case statusReason = "StatusReason"
        }
    }

    public struct ImageConfig: AWSEncodableShape & AWSDecodableShape {
        /// Specifies parameters that you want to pass in with ENTRYPOINT.
        public let command: [String]?
        /// Specifies the entry point to their application, which is typically the location of the runtime executable.
        public let entryPoint: [String]?
        /// Specifies the working directory.
        public let workingDirectory: String?

        public init(command: [String]? = nil, entryPoint: [String]? = nil, workingDirectory: String? = nil) {
            self.command = command
            self.entryPoint = entryPoint
            self.workingDirectory = workingDirectory
        }

        public func validate(name: String) throws {
            try self.validate(self.command, name: "command", parent: name, max: 1500)
            try self.validate(self.entryPoint, name: "entryPoint", parent: name, max: 1500)
            try self.validate(self.workingDirectory, name: "workingDirectory", parent: name, max: 1000)
        }

        private enum CodingKeys: String, CodingKey {
            case command = "Command"
            case entryPoint = "EntryPoint"
            case workingDirectory = "WorkingDirectory"
        }
    }

    public struct ImageConfigError: AWSDecodableShape {
        /// Error code.
        public let errorCode: String?
        /// Error message.
        public let message: String?

        public init(errorCode: String? = nil, message: String? = nil) {
            self.errorCode = errorCode
            self.message = message
        }

        private enum CodingKeys: String, CodingKey {
            case errorCode = "ErrorCode"
            case message = "Message"
        }
    }

    public struct ImageConfigResponse: AWSDecodableShape {
        /// Error response to GetFunctionConfiguration.
        public let error: ImageConfigError?
        /// Configuration values that override the container image Dockerfile.
        public let imageConfig: ImageConfig?

        public init(error: ImageConfigError? = nil, imageConfig: ImageConfig? = nil) {
            self.error = error
            self.imageConfig = imageConfig
        }

        private enum CodingKeys: String, CodingKey {
            case error = "Error"
            case imageConfig = "ImageConfig"
        }
    }

    public struct InvocationRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "payload"
        public static let _options: AWSShapeOptions = [.rawPayload]
        public static var _encoding = [
            AWSMemberEncoding(label: "clientContext", location: .header("X-Amz-Client-Context")),
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "invocationType", location: .header("X-Amz-Invocation-Type")),
            AWSMemberEncoding(label: "logType", location: .header("X-Amz-Log-Type")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// Up to 3,583 bytes of base64-encoded data about the invoking client to pass to the function in the context object.
        public let clientContext: String?
        /// The name of the Lambda function, version, or alias.  Name formats     Function name – my-function (name-only), my-function:v1 (with alias).    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Choose from the following options.    RequestResponse (default) – Invoke the function synchronously. Keep the connection open until the function returns a response or times out. The API response includes the function response and additional data.    Event – Invoke the function asynchronously. Send events that fail multiple times to the function's dead-letter queue (if one is configured). The API response only includes a status code.    DryRun – Validate parameter values and verify that the user or role has permission to invoke the function.
        public let invocationType: InvocationType?
        /// Set to Tail to include the execution log in the response. Applies to synchronously invoked functions only.
        public let logType: LogType?
        /// The JSON that you want to provide to your Lambda function as input. You can enter the JSON directly. For example, --payload '{ "key": "value" }'. You can also specify a file path. For example, --payload file://payload.json.
        public let payload: AWSPayload?
        /// Specify a version or alias to invoke a published version of the function.
        public let qualifier: String?

        public init(clientContext: String? = nil, functionName: String, invocationType: InvocationType? = nil, logType: LogType? = nil, payload: AWSPayload? = nil, qualifier: String? = nil) {
            self.clientContext = clientContext
            self.functionName = functionName
            self.invocationType = invocationType
            self.logType = logType
            self.payload = payload
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 170)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct InvocationResponse: AWSDecodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "payload"
        public static let _options: AWSShapeOptions = [.rawPayload]
        public static var _encoding = [
            AWSMemberEncoding(label: "executedVersion", location: .header("X-Amz-Executed-Version")),
            AWSMemberEncoding(label: "functionError", location: .header("X-Amz-Function-Error")),
            AWSMemberEncoding(label: "logResult", location: .header("X-Amz-Log-Result")),
            AWSMemberEncoding(label: "payload", location: .body("Payload")),
            AWSMemberEncoding(label: "statusCode", location: .statusCode)
        ]

        /// The version of the function that executed. When you invoke a function with an alias, this indicates which version the alias resolved to.
        public let executedVersion: String?
        /// If present, indicates that an error occurred during function execution. Details about the error are included in the response payload.
        public let functionError: String?
        /// The last 4 KB of the execution log, which is base64-encoded.
        public let logResult: String?
        /// The response from the function, or an error object.
        public let payload: AWSPayload?
        /// The HTTP status code is in the 200 range for a successful request. For the RequestResponse invocation type, this status code is 200. For the Event invocation type, this status code is 202. For the DryRun invocation type, the status code is 204.
        public let statusCode: Int?

        public init(executedVersion: String? = nil, functionError: String? = nil, logResult: String? = nil, payload: AWSPayload? = nil, statusCode: Int? = nil) {
            self.executedVersion = executedVersion
            self.functionError = functionError
            self.logResult = logResult
            self.payload = payload
            self.statusCode = statusCode
        }

        private enum CodingKeys: String, CodingKey {
            case executedVersion = "X-Amz-Executed-Version"
            case functionError = "X-Amz-Function-Error"
            case logResult = "X-Amz-Log-Result"
            case payload = "Payload"
            case statusCode = "StatusCode"
        }
    }

    public struct InvokeAsyncRequest: AWSEncodableShape & AWSShapeWithPayload {
        /// The key for the payload
        public static let _payloadPath: String = "invokeArgs"
        public static let _options: AWSShapeOptions = [.rawPayload, .allowStreaming]
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The JSON that you want to provide to your Lambda function as input.
        public let invokeArgs: AWSPayload

        public init(functionName: String, invokeArgs: AWSPayload) {
            self.functionName = functionName
            self.invokeArgs = invokeArgs
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 170)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct InvokeAsyncResponse: AWSDecodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "status", location: .statusCode)
        ]

        /// The status code.
        public let status: Int?

        public init(status: Int? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct Layer: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the function layer.
        public let arn: String?
        /// The size of the layer archive in bytes.
        public let codeSize: Int64?
        /// The Amazon Resource Name (ARN)  of a signing job.
        public let signingJobArn: String?
        /// The Amazon Resource Name (ARN) for a signing profile version.
        public let signingProfileVersionArn: String?

        public init(arn: String? = nil, codeSize: Int64? = nil, signingJobArn: String? = nil, signingProfileVersionArn: String? = nil) {
            self.arn = arn
            self.codeSize = codeSize
            self.signingJobArn = signingJobArn
            self.signingProfileVersionArn = signingProfileVersionArn
        }

        private enum CodingKeys: String, CodingKey {
            case arn = "Arn"
            case codeSize = "CodeSize"
            case signingJobArn = "SigningJobArn"
            case signingProfileVersionArn = "SigningProfileVersionArn"
        }
    }

    public struct LayerVersionContentInput: AWSEncodableShape {
        /// The Amazon S3 bucket of the layer archive.
        public let s3Bucket: String?
        /// The Amazon S3 key of the layer archive.
        public let s3Key: String?
        /// For versioned objects, the version of the layer archive object to use.
        public let s3ObjectVersion: String?
        /// The base64-encoded contents of the layer archive. Amazon Web Services SDK and Amazon Web Services CLI clients handle the encoding for you.
        public let zipFile: AWSBase64Data?

        public init(s3Bucket: String? = nil, s3Key: String? = nil, s3ObjectVersion: String? = nil, zipFile: AWSBase64Data? = nil) {
            self.s3Bucket = s3Bucket
            self.s3Key = s3Key
            self.s3ObjectVersion = s3ObjectVersion
            self.zipFile = zipFile
        }

        public func validate(name: String) throws {
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, max: 63)
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, min: 3)
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, pattern: "^[0-9A-Za-z\\.\\-_]*(?<!\\.)$")
            try self.validate(self.s3Key, name: "s3Key", parent: name, max: 1024)
            try self.validate(self.s3Key, name: "s3Key", parent: name, min: 1)
            try self.validate(self.s3ObjectVersion, name: "s3ObjectVersion", parent: name, max: 1024)
            try self.validate(self.s3ObjectVersion, name: "s3ObjectVersion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case s3Bucket = "S3Bucket"
            case s3Key = "S3Key"
            case s3ObjectVersion = "S3ObjectVersion"
            case zipFile = "ZipFile"
        }
    }

    public struct LayerVersionContentOutput: AWSDecodableShape {
        /// The SHA-256 hash of the layer archive.
        public let codeSha256: String?
        /// The size of the layer archive in bytes.
        public let codeSize: Int64?
        /// A link to the layer archive in Amazon S3 that is valid for 10 minutes.
        public let location: String?
        /// The Amazon Resource Name (ARN)  of a signing job.
        public let signingJobArn: String?
        /// The Amazon Resource Name (ARN) for a signing profile version.
        public let signingProfileVersionArn: String?

        public init(codeSha256: String? = nil, codeSize: Int64? = nil, location: String? = nil, signingJobArn: String? = nil, signingProfileVersionArn: String? = nil) {
            self.codeSha256 = codeSha256
            self.codeSize = codeSize
            self.location = location
            self.signingJobArn = signingJobArn
            self.signingProfileVersionArn = signingProfileVersionArn
        }

        private enum CodingKeys: String, CodingKey {
            case codeSha256 = "CodeSha256"
            case codeSize = "CodeSize"
            case location = "Location"
            case signingJobArn = "SigningJobArn"
            case signingProfileVersionArn = "SigningProfileVersionArn"
        }
    }

    public struct LayerVersionsListItem: AWSDecodableShape {
        /// A list of compatible   instruction set architectures.
        public let compatibleArchitectures: [Architecture]?
        /// The layer's compatible runtimes.
        public let compatibleRuntimes: [Runtime]?
        /// The date that the version was created, in ISO 8601 format. For example, 2018-11-27T15:10:45.123+0000.
        public let createdDate: String?
        /// The description of the version.
        public let description: String?
        /// The ARN of the layer version.
        public let layerVersionArn: String?
        /// The layer's open-source license.
        public let licenseInfo: String?
        /// The version number.
        public let version: Int64?

        public init(compatibleArchitectures: [Architecture]? = nil, compatibleRuntimes: [Runtime]? = nil, createdDate: String? = nil, description: String? = nil, layerVersionArn: String? = nil, licenseInfo: String? = nil, version: Int64? = nil) {
            self.compatibleArchitectures = compatibleArchitectures
            self.compatibleRuntimes = compatibleRuntimes
            self.createdDate = createdDate
            self.description = description
            self.layerVersionArn = layerVersionArn
            self.licenseInfo = licenseInfo
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case compatibleArchitectures = "CompatibleArchitectures"
            case compatibleRuntimes = "CompatibleRuntimes"
            case createdDate = "CreatedDate"
            case description = "Description"
            case layerVersionArn = "LayerVersionArn"
            case licenseInfo = "LicenseInfo"
            case version = "Version"
        }
    }

    public struct LayersListItem: AWSDecodableShape {
        /// The newest version of the layer.
        public let latestMatchingVersion: LayerVersionsListItem?
        /// The Amazon Resource Name (ARN) of the function layer.
        public let layerArn: String?
        /// The name of the layer.
        public let layerName: String?

        public init(latestMatchingVersion: LayerVersionsListItem? = nil, layerArn: String? = nil, layerName: String? = nil) {
            self.latestMatchingVersion = latestMatchingVersion
            self.layerArn = layerArn
            self.layerName = layerName
        }

        private enum CodingKeys: String, CodingKey {
            case latestMatchingVersion = "LatestMatchingVersion"
            case layerArn = "LayerArn"
            case layerName = "LayerName"
        }
    }

    public struct ListAliasesRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "functionVersion", location: .querystring("FunctionVersion")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify a function version to only list aliases that invoke that version.
        public let functionVersion: String?
        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// Limit the number of aliases returned.
        public let maxItems: Int?

        public init(functionName: String, functionVersion: String? = nil, marker: String? = nil, maxItems: Int? = nil) {
            self.functionName = functionName
            self.functionVersion = functionVersion
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, max: 1024)
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, min: 1)
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, pattern: "^(\\$LATEST|[0-9]+)$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 10000)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListAliasesResponse: AWSDecodableShape {
        /// A list of aliases.
        public let aliases: [AliasConfiguration]?
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?

        public init(aliases: [AliasConfiguration]? = nil, nextMarker: String? = nil) {
            self.aliases = aliases
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case aliases = "Aliases"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListCodeSigningConfigsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// Maximum number of items to return.
        public let maxItems: Int?

        public init(marker: String? = nil, maxItems: Int? = nil) {
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 10000)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListCodeSigningConfigsResponse: AWSDecodableShape {
        /// The code signing configurations
        public let codeSigningConfigs: [CodeSigningConfig]?
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?

        public init(codeSigningConfigs: [CodeSigningConfig]? = nil, nextMarker: String? = nil) {
            self.codeSigningConfigs = codeSigningConfigs
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case codeSigningConfigs = "CodeSigningConfigs"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListEventSourceMappingsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "eventSourceArn", location: .querystring("EventSourceArn")),
            AWSMemberEncoding(label: "functionName", location: .querystring("FunctionName")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The Amazon Resource Name (ARN) of the event source.    Amazon Kinesis - The ARN of the data stream or a stream consumer.    Amazon DynamoDB Streams - The ARN of the stream.    Amazon Simple Queue Service - The ARN of the queue.    Amazon Managed Streaming for Apache Kafka - The ARN of the cluster.    Amazon MQ - The ARN of the broker.
        public let eventSourceArn: String?
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Version or Alias ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it's limited to 64 characters in length.
        public let functionName: String?
        /// A pagination token returned by a previous call.
        public let marker: String?
        /// The maximum number of event source mappings to return. Note that ListEventSourceMappings returns a maximum of 100 items in each response, even if you set the number higher.
        public let maxItems: Int?

        public init(eventSourceArn: String? = nil, functionName: String? = nil, marker: String? = nil, maxItems: Int? = nil) {
            self.eventSourceArn = eventSourceArn
            self.functionName = functionName
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.eventSourceArn, name: "eventSourceArn", parent: name, pattern: "^arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\\-])+:([a-z]{2}(-gov)?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)$")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 10000)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListEventSourceMappingsResponse: AWSDecodableShape {
        /// A list of event source mappings.
        public let eventSourceMappings: [EventSourceMappingConfiguration]?
        /// A pagination token that's returned when the response doesn't contain all event source mappings.
        public let nextMarker: String?

        public init(eventSourceMappings: [EventSourceMappingConfiguration]? = nil, nextMarker: String? = nil) {
            self.eventSourceMappings = eventSourceMappings
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case eventSourceMappings = "EventSourceMappings"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListFunctionEventInvokeConfigsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The name of the Lambda function.  Name formats     Function name - my-function.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN - 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// The maximum number of configurations to return.
        public let maxItems: Int?

        public init(functionName: String, marker: String? = nil, maxItems: Int? = nil) {
            self.functionName = functionName
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 50)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListFunctionEventInvokeConfigsResponse: AWSDecodableShape {
        /// A list of configurations.
        public let functionEventInvokeConfigs: [FunctionEventInvokeConfig]?
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?

        public init(functionEventInvokeConfigs: [FunctionEventInvokeConfig]? = nil, nextMarker: String? = nil) {
            self.functionEventInvokeConfigs = functionEventInvokeConfigs
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case functionEventInvokeConfigs = "FunctionEventInvokeConfigs"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListFunctionUrlConfigsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// The maximum number of function URLs to return in the response. Note that ListFunctionUrlConfigs returns a maximum of 50 items in each response, even if you set the number higher.
        public let maxItems: Int?

        public init(functionName: String, marker: String? = nil, maxItems: Int? = nil) {
            self.functionName = functionName
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 50)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListFunctionUrlConfigsResponse: AWSDecodableShape {
        /// A list of function URL configurations.
        public let functionUrlConfigs: [FunctionUrlConfig]
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?

        public init(functionUrlConfigs: [FunctionUrlConfig], nextMarker: String? = nil) {
            self.functionUrlConfigs = functionUrlConfigs
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case functionUrlConfigs = "FunctionUrlConfigs"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListFunctionsByCodeSigningConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "codeSigningConfigArn", location: .uri("CodeSigningConfigArn")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The The Amazon Resource Name (ARN) of the code signing configuration.
        public let codeSigningConfigArn: String
        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// Maximum number of items to return.
        public let maxItems: Int?

        public init(codeSigningConfigArn: String, marker: String? = nil, maxItems: Int? = nil) {
            self.codeSigningConfigArn = codeSigningConfigArn
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, max: 200)
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:\\d{12}:code-signing-config:csc-[a-z0-9]{17}$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 10000)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListFunctionsByCodeSigningConfigResponse: AWSDecodableShape {
        /// The function ARNs.
        public let functionArns: [String]?
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?

        public init(functionArns: [String]? = nil, nextMarker: String? = nil) {
            self.functionArns = functionArns
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case functionArns = "FunctionArns"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListFunctionsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionVersion", location: .querystring("FunctionVersion")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "masterRegion", location: .querystring("MasterRegion")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// Set to ALL to include entries for all published versions of each function.
        public let functionVersion: FunctionVersion?
        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// For Lambda@Edge functions, the Amazon Web Services Region of the master function. For example, us-east-1 filters the list of functions to include only Lambda@Edge functions replicated from a master function in US East (N. Virginia). If specified, you must set FunctionVersion to ALL.
        public let masterRegion: SotoCore.Region?
        /// The maximum number of functions to return in the response. Note that ListFunctions returns a maximum of 50 items in each response, even if you set the number higher.
        public let maxItems: Int?

        public init(functionVersion: FunctionVersion? = nil, marker: String? = nil, masterRegion: SotoCore.Region? = nil, maxItems: Int? = nil) {
            self.functionVersion = functionVersion
            self.marker = marker
            self.masterRegion = masterRegion
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 10000)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListFunctionsResponse: AWSDecodableShape {
        /// A list of Lambda functions.
        public let functions: [FunctionConfiguration]?
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?

        public init(functions: [FunctionConfiguration]? = nil, nextMarker: String? = nil) {
            self.functions = functions
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case functions = "Functions"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListLayerVersionsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "compatibleArchitecture", location: .querystring("CompatibleArchitecture")),
            AWSMemberEncoding(label: "compatibleRuntime", location: .querystring("CompatibleRuntime")),
            AWSMemberEncoding(label: "layerName", location: .uri("LayerName")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The compatible
        /// instruction set architecture.
        public let compatibleArchitecture: Architecture?
        /// A runtime identifier. For example, go1.x.
        public let compatibleRuntime: Runtime?
        /// The name or Amazon Resource Name (ARN) of the layer.
        public let layerName: String
        /// A pagination token returned by a previous call.
        public let marker: String?
        /// The maximum number of versions to return.
        public let maxItems: Int?

        public init(compatibleArchitecture: Architecture? = nil, compatibleRuntime: Runtime? = nil, layerName: String, marker: String? = nil, maxItems: Int? = nil) {
            self.compatibleArchitecture = compatibleArchitecture
            self.compatibleRuntime = compatibleRuntime
            self.layerName = layerName
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.layerName, name: "layerName", parent: name, max: 140)
            try self.validate(self.layerName, name: "layerName", parent: name, min: 1)
            try self.validate(self.layerName, name: "layerName", parent: name, pattern: "^(arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+)|[a-zA-Z0-9-_]+$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 50)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListLayerVersionsResponse: AWSDecodableShape {
        /// A list of versions.
        public let layerVersions: [LayerVersionsListItem]?
        /// A pagination token returned when the response doesn't contain all versions.
        public let nextMarker: String?

        public init(layerVersions: [LayerVersionsListItem]? = nil, nextMarker: String? = nil) {
            self.layerVersions = layerVersions
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case layerVersions = "LayerVersions"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListLayersRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "compatibleArchitecture", location: .querystring("CompatibleArchitecture")),
            AWSMemberEncoding(label: "compatibleRuntime", location: .querystring("CompatibleRuntime")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The compatible
        /// instruction set architecture.
        public let compatibleArchitecture: Architecture?
        /// A runtime identifier. For example, go1.x.
        public let compatibleRuntime: Runtime?
        /// A pagination token returned by a previous call.
        public let marker: String?
        /// The maximum number of layers to return.
        public let maxItems: Int?

        public init(compatibleArchitecture: Architecture? = nil, compatibleRuntime: Runtime? = nil, marker: String? = nil, maxItems: Int? = nil) {
            self.compatibleArchitecture = compatibleArchitecture
            self.compatibleRuntime = compatibleRuntime
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 50)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListLayersResponse: AWSDecodableShape {
        /// A list of function layers.
        public let layers: [LayersListItem]?
        /// A pagination token returned when the response doesn't contain all layers.
        public let nextMarker: String?

        public init(layers: [LayersListItem]? = nil, nextMarker: String? = nil) {
            self.layers = layers
            self.nextMarker = nextMarker
        }

        private enum CodingKeys: String, CodingKey {
            case layers = "Layers"
            case nextMarker = "NextMarker"
        }
    }

    public struct ListProvisionedConcurrencyConfigsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// Specify a number to limit the number of configurations returned.
        public let maxItems: Int?

        public init(functionName: String, marker: String? = nil, maxItems: Int? = nil) {
            self.functionName = functionName
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 50)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListProvisionedConcurrencyConfigsResponse: AWSDecodableShape {
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?
        /// A list of provisioned concurrency configurations.
        public let provisionedConcurrencyConfigs: [ProvisionedConcurrencyConfigListItem]?

        public init(nextMarker: String? = nil, provisionedConcurrencyConfigs: [ProvisionedConcurrencyConfigListItem]? = nil) {
            self.nextMarker = nextMarker
            self.provisionedConcurrencyConfigs = provisionedConcurrencyConfigs
        }

        private enum CodingKeys: String, CodingKey {
            case nextMarker = "NextMarker"
            case provisionedConcurrencyConfigs = "ProvisionedConcurrencyConfigs"
        }
    }

    public struct ListTagsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "resource", location: .uri("Resource"))
        ]

        /// The function's Amazon Resource Name (ARN).  Note: Lambda does not support adding tags to aliases or versions.
        public let resource: String

        public init(resource: String) {
            self.resource = resource
        }

        public func validate(name: String) throws {
            try self.validate(self.resource, name: "resource", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\\d{1}:\\d{12}:function:[a-zA-Z0-9-_]+(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListTagsResponse: AWSDecodableShape {
        /// The function's tags.
        public let tags: [String: String]?

        public init(tags: [String: String]? = nil) {
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case tags = "Tags"
        }
    }

    public struct ListVersionsByFunctionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "marker", location: .querystring("Marker")),
            AWSMemberEncoding(label: "maxItems", location: .querystring("MaxItems"))
        ]

        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify the pagination token that's returned by a previous request to retrieve the next page of results.
        public let marker: String?
        /// The maximum number of versions to return. Note that ListVersionsByFunction returns a maximum of 50 items in each response,  even if you set the number higher.
        public let maxItems: Int?

        public init(functionName: String, marker: String? = nil, maxItems: Int? = nil) {
            self.functionName = functionName
            self.marker = marker
            self.maxItems = maxItems
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 170)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_\\.]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.maxItems, name: "maxItems", parent: name, max: 10000)
            try self.validate(self.maxItems, name: "maxItems", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListVersionsByFunctionResponse: AWSDecodableShape {
        /// The pagination token that's included if more results are available.
        public let nextMarker: String?
        /// A list of Lambda function versions.
        public let versions: [FunctionConfiguration]?

        public init(nextMarker: String? = nil, versions: [FunctionConfiguration]? = nil) {
            self.nextMarker = nextMarker
            self.versions = versions
        }

        private enum CodingKeys: String, CodingKey {
            case nextMarker = "NextMarker"
            case versions = "Versions"
        }
    }

    public struct OnFailure: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the destination resource.
        public let destination: String?

        public init(destination: String? = nil) {
            self.destination = destination
        }

        public func validate(name: String) throws {
            try self.validate(self.destination, name: "destination", parent: name, max: 350)
            try self.validate(self.destination, name: "destination", parent: name, pattern: "^$|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\\-])+:([a-z]{2}(-gov)?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)$")
        }

        private enum CodingKeys: String, CodingKey {
            case destination = "Destination"
        }
    }

    public struct OnSuccess: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the destination resource.
        public let destination: String?

        public init(destination: String? = nil) {
            self.destination = destination
        }

        public func validate(name: String) throws {
            try self.validate(self.destination, name: "destination", parent: name, max: 350)
            try self.validate(self.destination, name: "destination", parent: name, pattern: "^$|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\\-])+:([a-z]{2}(-gov)?-[a-z]+-\\d{1})?:(\\d{12})?:(.*)$")
        }

        private enum CodingKeys: String, CodingKey {
            case destination = "Destination"
        }
    }

    public struct ProvisionedConcurrencyConfigListItem: AWSDecodableShape {
        /// The amount of provisioned concurrency allocated. When a weighted alias is used during linear and canary deployments, this value fluctuates depending on the amount of concurrency that is provisioned for the function versions.
        public let allocatedProvisionedConcurrentExecutions: Int?
        /// The amount of provisioned concurrency available.
        public let availableProvisionedConcurrentExecutions: Int?
        /// The Amazon Resource Name (ARN) of the alias or version.
        public let functionArn: String?
        /// The date and time that a user last updated the configuration, in ISO 8601 format.
        public let lastModified: String?
        /// The amount of provisioned concurrency requested.
        public let requestedProvisionedConcurrentExecutions: Int?
        /// The status of the allocation process.
        public let status: ProvisionedConcurrencyStatusEnum?
        /// For failed allocations, the reason that provisioned concurrency could not be allocated.
        public let statusReason: String?

        public init(allocatedProvisionedConcurrentExecutions: Int? = nil, availableProvisionedConcurrentExecutions: Int? = nil, functionArn: String? = nil, lastModified: String? = nil, requestedProvisionedConcurrentExecutions: Int? = nil, status: ProvisionedConcurrencyStatusEnum? = nil, statusReason: String? = nil) {
            self.allocatedProvisionedConcurrentExecutions = allocatedProvisionedConcurrentExecutions
            self.availableProvisionedConcurrentExecutions = availableProvisionedConcurrentExecutions
            self.functionArn = functionArn
            self.lastModified = lastModified
            self.requestedProvisionedConcurrentExecutions = requestedProvisionedConcurrentExecutions
            self.status = status
            self.statusReason = statusReason
        }

        private enum CodingKeys: String, CodingKey {
            case allocatedProvisionedConcurrentExecutions = "AllocatedProvisionedConcurrentExecutions"
            case availableProvisionedConcurrentExecutions = "AvailableProvisionedConcurrentExecutions"
            case functionArn = "FunctionArn"
            case lastModified = "LastModified"
            case requestedProvisionedConcurrentExecutions = "RequestedProvisionedConcurrentExecutions"
            case status = "Status"
            case statusReason = "StatusReason"
        }
    }

    public struct PublishLayerVersionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "layerName", location: .uri("LayerName"))
        ]

        /// A list of compatible
        /// instruction set architectures.
        public let compatibleArchitectures: [Architecture]?
        /// A list of compatible function runtimes. Used for filtering with ListLayers and ListLayerVersions.
        public let compatibleRuntimes: [Runtime]?
        /// The function layer archive.
        public let content: LayerVersionContentInput
        /// The description of the version.
        public let description: String?
        /// The name or Amazon Resource Name (ARN) of the layer.
        public let layerName: String
        /// The layer's software license. It can be any of the following:   An SPDX license identifier. For example, MIT.   The URL of a license hosted on the internet. For example, https://opensource.org/licenses/MIT.   The full text of the license.
        public let licenseInfo: String?

        public init(compatibleArchitectures: [Architecture]? = nil, compatibleRuntimes: [Runtime]? = nil, content: LayerVersionContentInput, description: String? = nil, layerName: String, licenseInfo: String? = nil) {
            self.compatibleArchitectures = compatibleArchitectures
            self.compatibleRuntimes = compatibleRuntimes
            self.content = content
            self.description = description
            self.layerName = layerName
            self.licenseInfo = licenseInfo
        }

        public func validate(name: String) throws {
            try self.validate(self.compatibleArchitectures, name: "compatibleArchitectures", parent: name, max: 2)
            try self.validate(self.compatibleRuntimes, name: "compatibleRuntimes", parent: name, max: 15)
            try self.content.validate(name: "\(name).content")
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.layerName, name: "layerName", parent: name, max: 140)
            try self.validate(self.layerName, name: "layerName", parent: name, min: 1)
            try self.validate(self.layerName, name: "layerName", parent: name, pattern: "^(arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+)|[a-zA-Z0-9-_]+$")
            try self.validate(self.licenseInfo, name: "licenseInfo", parent: name, max: 512)
        }

        private enum CodingKeys: String, CodingKey {
            case compatibleArchitectures = "CompatibleArchitectures"
            case compatibleRuntimes = "CompatibleRuntimes"
            case content = "Content"
            case description = "Description"
            case licenseInfo = "LicenseInfo"
        }
    }

    public struct PublishLayerVersionResponse: AWSDecodableShape {
        /// A list of compatible
        /// instruction set architectures.
        public let compatibleArchitectures: [Architecture]?
        /// The layer's compatible runtimes.
        public let compatibleRuntimes: [Runtime]?
        /// Details about the layer version.
        public let content: LayerVersionContentOutput?
        /// The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let createdDate: String?
        /// The description of the version.
        public let description: String?
        /// The ARN of the layer.
        public let layerArn: String?
        /// The ARN of the layer version.
        public let layerVersionArn: String?
        /// The layer's software license.
        public let licenseInfo: String?
        /// The version number.
        public let version: Int64?

        public init(compatibleArchitectures: [Architecture]? = nil, compatibleRuntimes: [Runtime]? = nil, content: LayerVersionContentOutput? = nil, createdDate: String? = nil, description: String? = nil, layerArn: String? = nil, layerVersionArn: String? = nil, licenseInfo: String? = nil, version: Int64? = nil) {
            self.compatibleArchitectures = compatibleArchitectures
            self.compatibleRuntimes = compatibleRuntimes
            self.content = content
            self.createdDate = createdDate
            self.description = description
            self.layerArn = layerArn
            self.layerVersionArn = layerVersionArn
            self.licenseInfo = licenseInfo
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case compatibleArchitectures = "CompatibleArchitectures"
            case compatibleRuntimes = "CompatibleRuntimes"
            case content = "Content"
            case createdDate = "CreatedDate"
            case description = "Description"
            case layerArn = "LayerArn"
            case layerVersionArn = "LayerVersionArn"
            case licenseInfo = "LicenseInfo"
            case version = "Version"
        }
    }

    public struct PublishVersionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// Only publish a version if the hash value matches the value that's specified. Use this option to avoid publishing a version if the function code has changed since you last updated it. You can get the hash for the version that you uploaded from the output of UpdateFunctionCode.
        public let codeSha256: String?
        /// A description for the version to override the description in the function configuration.
        public let description: String?
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Only update the function if the revision ID matches the ID that's specified. Use this option to avoid publishing a version if the function configuration has changed since you last updated it.
        public let revisionId: String?

        public init(codeSha256: String? = nil, description: String? = nil, functionName: String, revisionId: String? = nil) {
            self.codeSha256 = codeSha256
            self.description = description
            self.functionName = functionName
            self.revisionId = revisionId
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: String, CodingKey {
            case codeSha256 = "CodeSha256"
            case description = "Description"
            case revisionId = "RevisionId"
        }
    }

    public struct PutFunctionCodeSigningConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The The Amazon Resource Name (ARN) of the code signing configuration.
        public let codeSigningConfigArn: String
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String

        public init(codeSigningConfigArn: String, functionName: String) {
            self.codeSigningConfigArn = codeSigningConfigArn
            self.functionName = functionName
        }

        public func validate(name: String) throws {
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, max: 200)
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:\\d{12}:code-signing-config:csc-[a-z0-9]{17}$")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: String, CodingKey {
            case codeSigningConfigArn = "CodeSigningConfigArn"
        }
    }

    public struct PutFunctionCodeSigningConfigResponse: AWSDecodableShape {
        /// The The Amazon Resource Name (ARN) of the code signing configuration.
        public let codeSigningConfigArn: String
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String

        public init(codeSigningConfigArn: String, functionName: String) {
            self.codeSigningConfigArn = codeSigningConfigArn
            self.functionName = functionName
        }

        private enum CodingKeys: String, CodingKey {
            case codeSigningConfigArn = "CodeSigningConfigArn"
            case functionName = "FunctionName"
        }
    }

    public struct PutFunctionConcurrencyRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The number of simultaneous executions to reserve for the function.
        public let reservedConcurrentExecutions: Int

        public init(functionName: String, reservedConcurrentExecutions: Int) {
            self.functionName = functionName
            self.reservedConcurrentExecutions = reservedConcurrentExecutions
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.reservedConcurrentExecutions, name: "reservedConcurrentExecutions", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case reservedConcurrentExecutions = "ReservedConcurrentExecutions"
        }
    }

    public struct PutFunctionEventInvokeConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// A destination for events after they have been sent to a function for processing.  Destinations     Function - The Amazon Resource Name (ARN) of a Lambda function.    Queue - The ARN of an SQS queue.    Topic - The ARN of an SNS topic.    Event Bus - The ARN of an Amazon EventBridge event bus.
        public let destinationConfig: DestinationConfig?
        /// The name of the Lambda function, version, or alias.  Name formats     Function name - my-function (name-only), my-function:v1 (with alias).    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN - 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The maximum age of a request that Lambda sends to a function for processing.
        public let maximumEventAgeInSeconds: Int?
        /// The maximum number of times to retry when the function returns an error.
        public let maximumRetryAttempts: Int?
        /// A version number or alias name.
        public let qualifier: String?

        public init(destinationConfig: DestinationConfig? = nil, functionName: String, maximumEventAgeInSeconds: Int? = nil, maximumRetryAttempts: Int? = nil, qualifier: String? = nil) {
            self.destinationConfig = destinationConfig
            self.functionName = functionName
            self.maximumEventAgeInSeconds = maximumEventAgeInSeconds
            self.maximumRetryAttempts = maximumRetryAttempts
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.destinationConfig?.validate(name: "\(name).destinationConfig")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.maximumEventAgeInSeconds, name: "maximumEventAgeInSeconds", parent: name, max: 21600)
            try self.validate(self.maximumEventAgeInSeconds, name: "maximumEventAgeInSeconds", parent: name, min: 60)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, max: 2)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, min: 0)
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: String, CodingKey {
            case destinationConfig = "DestinationConfig"
            case maximumEventAgeInSeconds = "MaximumEventAgeInSeconds"
            case maximumRetryAttempts = "MaximumRetryAttempts"
        }
    }

    public struct PutProvisionedConcurrencyConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The amount of provisioned concurrency to allocate for the version or alias.
        public let provisionedConcurrentExecutions: Int
        /// The version number or alias name.
        public let qualifier: String

        public init(functionName: String, provisionedConcurrentExecutions: Int, qualifier: String) {
            self.functionName = functionName
            self.provisionedConcurrentExecutions = provisionedConcurrentExecutions
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.provisionedConcurrentExecutions, name: "provisionedConcurrentExecutions", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: String, CodingKey {
            case provisionedConcurrentExecutions = "ProvisionedConcurrentExecutions"
        }
    }

    public struct PutProvisionedConcurrencyConfigResponse: AWSDecodableShape {
        /// The amount of provisioned concurrency allocated. When a weighted alias is used during linear and canary deployments, this value fluctuates depending on the amount of concurrency that is provisioned for the function versions.
        public let allocatedProvisionedConcurrentExecutions: Int?
        /// The amount of provisioned concurrency available.
        public let availableProvisionedConcurrentExecutions: Int?
        /// The date and time that a user last updated the configuration, in ISO 8601 format.
        public let lastModified: String?
        /// The amount of provisioned concurrency requested.
        public let requestedProvisionedConcurrentExecutions: Int?
        /// The status of the allocation process.
        public let status: ProvisionedConcurrencyStatusEnum?
        /// For failed allocations, the reason that provisioned concurrency could not be allocated.
        public let statusReason: String?

        public init(allocatedProvisionedConcurrentExecutions: Int? = nil, availableProvisionedConcurrentExecutions: Int? = nil, lastModified: String? = nil, requestedProvisionedConcurrentExecutions: Int? = nil, status: ProvisionedConcurrencyStatusEnum? = nil, statusReason: String? = nil) {
            self.allocatedProvisionedConcurrentExecutions = allocatedProvisionedConcurrentExecutions
            self.availableProvisionedConcurrentExecutions = availableProvisionedConcurrentExecutions
            self.lastModified = lastModified
            self.requestedProvisionedConcurrentExecutions = requestedProvisionedConcurrentExecutions
            self.status = status
            self.statusReason = statusReason
        }

        private enum CodingKeys: String, CodingKey {
            case allocatedProvisionedConcurrentExecutions = "AllocatedProvisionedConcurrentExecutions"
            case availableProvisionedConcurrentExecutions = "AvailableProvisionedConcurrentExecutions"
            case lastModified = "LastModified"
            case requestedProvisionedConcurrentExecutions = "RequestedProvisionedConcurrentExecutions"
            case status = "Status"
            case statusReason = "StatusReason"
        }
    }

    public struct RemoveLayerVersionPermissionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "layerName", location: .uri("LayerName")),
            AWSMemberEncoding(label: "revisionId", location: .querystring("RevisionId")),
            AWSMemberEncoding(label: "statementId", location: .uri("StatementId")),
            AWSMemberEncoding(label: "versionNumber", location: .uri("VersionNumber"))
        ]

        /// The name or Amazon Resource Name (ARN) of the layer.
        public let layerName: String
        /// Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a policy that has changed since you last read it.
        public let revisionId: String?
        /// The identifier that was specified when the statement was added.
        public let statementId: String
        /// The version number.
        public let versionNumber: Int64

        public init(layerName: String, revisionId: String? = nil, statementId: String, versionNumber: Int64 = 0) {
            self.layerName = layerName
            self.revisionId = revisionId
            self.statementId = statementId
            self.versionNumber = versionNumber
        }

        public func validate(name: String) throws {
            try self.validate(self.layerName, name: "layerName", parent: name, max: 140)
            try self.validate(self.layerName, name: "layerName", parent: name, min: 1)
            try self.validate(self.layerName, name: "layerName", parent: name, pattern: "^(arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+)|[a-zA-Z0-9-_]+$")
            try self.validate(self.statementId, name: "statementId", parent: name, max: 100)
            try self.validate(self.statementId, name: "statementId", parent: name, min: 1)
            try self.validate(self.statementId, name: "statementId", parent: name, pattern: "^([a-zA-Z0-9-_]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct RemovePermissionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier")),
            AWSMemberEncoding(label: "revisionId", location: .querystring("RevisionId")),
            AWSMemberEncoding(label: "statementId", location: .uri("StatementId"))
        ]

        /// The name of the Lambda function, version, or alias.  Name formats     Function name – my-function (name-only), my-function:v1 (with alias).    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// Specify a version or alias to remove permissions from a published version of the function.
        public let qualifier: String?
        /// Update the policy only if the revision ID matches the ID that's specified. Use this option to avoid modifying a policy that has changed since you last read it.
        public let revisionId: String?
        /// Statement ID of the permission to remove.
        public let statementId: String

        public init(functionName: String, qualifier: String? = nil, revisionId: String? = nil, statementId: String) {
            self.functionName = functionName
            self.qualifier = qualifier
            self.revisionId = revisionId
            self.statementId = statementId
        }

        public func validate(name: String) throws {
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
            try self.validate(self.statementId, name: "statementId", parent: name, max: 100)
            try self.validate(self.statementId, name: "statementId", parent: name, min: 1)
            try self.validate(self.statementId, name: "statementId", parent: name, pattern: "^([a-zA-Z0-9-_.]+)$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct SelfManagedEventSource: AWSEncodableShape & AWSDecodableShape {
        /// The list of bootstrap servers for your Kafka brokers in the following format: "KAFKA_BOOTSTRAP_SERVERS": ["abc.xyz.com:xxxx","abc2.xyz.com:xxxx"].
        public let endpoints: [EndPointType: [String]]?

        public init(endpoints: [EndPointType: [String]]? = nil) {
            self.endpoints = endpoints
        }

        public func validate(name: String) throws {
            try self.endpoints?.forEach {
                try validate($0.value, name: "endpoints[\"\($0.key)\"]", parent: name, max: 10)
                try validate($0.value, name: "endpoints[\"\($0.key)\"]", parent: name, min: 1)
            }
            try self.validate(self.endpoints, name: "endpoints", parent: name, max: 2)
            try self.validate(self.endpoints, name: "endpoints", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case endpoints = "Endpoints"
        }
    }

    public struct SelfManagedKafkaEventSourceConfig: AWSEncodableShape & AWSDecodableShape {
        /// The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. For more information, see Customizable consumer group ID.
        public let consumerGroupId: String?

        public init(consumerGroupId: String? = nil) {
            self.consumerGroupId = consumerGroupId
        }

        public func validate(name: String) throws {
            try self.validate(self.consumerGroupId, name: "consumerGroupId", parent: name, max: 200)
            try self.validate(self.consumerGroupId, name: "consumerGroupId", parent: name, min: 1)
            try self.validate(self.consumerGroupId, name: "consumerGroupId", parent: name, pattern: "^[a-zA-Z0-9-\\/*:_+=.@-]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case consumerGroupId = "ConsumerGroupId"
        }
    }

    public struct SnapStart: AWSEncodableShape {
        /// Set to PublishedVersions to create a snapshot of the initialized execution environment when you publish a function version.
        public let applyOn: SnapStartApplyOn?

        public init(applyOn: SnapStartApplyOn? = nil) {
            self.applyOn = applyOn
        }

        private enum CodingKeys: String, CodingKey {
            case applyOn = "ApplyOn"
        }
    }

    public struct SnapStartResponse: AWSDecodableShape {
        /// When set to PublishedVersions, Lambda creates a snapshot of the execution environment when you publish a function version.
        public let applyOn: SnapStartApplyOn?
        /// When you provide a qualified Amazon Resource Name (ARN), this response element indicates whether SnapStart is activated for the specified function version.
        public let optimizationStatus: SnapStartOptimizationStatus?

        public init(applyOn: SnapStartApplyOn? = nil, optimizationStatus: SnapStartOptimizationStatus? = nil) {
            self.applyOn = applyOn
            self.optimizationStatus = optimizationStatus
        }

        private enum CodingKeys: String, CodingKey {
            case applyOn = "ApplyOn"
            case optimizationStatus = "OptimizationStatus"
        }
    }

    public struct SourceAccessConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// The type of authentication protocol, VPC components, or virtual host for your event source. For example: "Type":"SASL_SCRAM_512_AUTH".    BASIC_AUTH - (Amazon MQ) The Secrets Manager secret that stores your broker credentials.    BASIC_AUTH - (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL/PLAIN authentication of your Apache Kafka brokers.    VPC_SUBNET - (Self-managed Apache Kafka) The subnets associated with your VPC. Lambda connects to these subnets to fetch data from your self-managed Apache Kafka cluster.    VPC_SECURITY_GROUP - (Self-managed Apache Kafka) The VPC security group used to manage access to your self-managed Apache Kafka brokers.    SASL_SCRAM_256_AUTH - (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL SCRAM-256 authentication of your self-managed Apache Kafka brokers.    SASL_SCRAM_512_AUTH - (Amazon MSK, Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL SCRAM-512 authentication of your self-managed Apache Kafka brokers.    VIRTUAL_HOST - (RabbitMQ) The name of the virtual host in your RabbitMQ broker. Lambda uses this RabbitMQ host as the event source.  This property cannot be specified in an UpdateEventSourceMapping API call.    CLIENT_CERTIFICATE_TLS_AUTH - (Amazon MSK, self-managed Apache Kafka) The Secrets Manager ARN of your secret key containing the certificate chain (X.509 PEM),  private key (PKCS#8 PEM), and private key password (optional) used for mutual TLS authentication of your MSK/Apache Kafka brokers.    SERVER_ROOT_CA_CERTIFICATE - (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key containing the root CA certificate (X.509 PEM) used for TLS encryption of your Apache Kafka brokers.
        public let type: SourceAccessType?
        /// The value for your chosen configuration in Type. For example: "URI": "arn:aws:secretsmanager:us-east-1:01234567890:secret:MyBrokerSecretName".
        public let uri: String?

        public init(type: SourceAccessType? = nil, uri: String? = nil) {
            self.type = type
            self.uri = uri
        }

        public func validate(name: String) throws {
            try self.validate(self.uri, name: "uri", parent: name, max: 200)
            try self.validate(self.uri, name: "uri", parent: name, min: 1)
            try self.validate(self.uri, name: "uri", parent: name, pattern: "^[a-zA-Z0-9-\\/*:_+=.@-]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case type = "Type"
            case uri = "URI"
        }
    }

    public struct TagResourceRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "resource", location: .uri("Resource"))
        ]

        /// The function's Amazon Resource Name (ARN).
        public let resource: String
        /// A list of tags to apply to the function.
        public let tags: [String: String]

        public init(resource: String, tags: [String: String]) {
            self.resource = resource
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.resource, name: "resource", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\\d{1}:\\d{12}:function:[a-zA-Z0-9-_]+(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: String, CodingKey {
            case tags = "Tags"
        }
    }

    public struct TracingConfig: AWSEncodableShape {
        /// The tracing mode.
        public let mode: TracingMode?

        public init(mode: TracingMode? = nil) {
            self.mode = mode
        }

        private enum CodingKeys: String, CodingKey {
            case mode = "Mode"
        }
    }

    public struct TracingConfigResponse: AWSDecodableShape {
        /// The tracing mode.
        public let mode: TracingMode?

        public init(mode: TracingMode? = nil) {
            self.mode = mode
        }

        private enum CodingKeys: String, CodingKey {
            case mode = "Mode"
        }
    }

    public struct UntagResourceRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "resource", location: .uri("Resource")),
            AWSMemberEncoding(label: "tagKeys", location: .querystring("tagKeys"))
        ]

        /// The function's Amazon Resource Name (ARN).
        public let resource: String
        /// A list of tag keys to remove from the function.
        public let tagKeys: [String]

        public init(resource: String, tagKeys: [String]) {
            self.resource = resource
            self.tagKeys = tagKeys
        }

        public func validate(name: String) throws {
            try self.validate(self.resource, name: "resource", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\\d{1}:\\d{12}:function:[a-zA-Z0-9-_]+(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct UpdateAliasRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "name", location: .uri("Name"))
        ]

        /// A description of the alias.
        public let description: String?
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The function version that the alias invokes.
        public let functionVersion: String?
        /// The name of the alias.
        public let name: String
        /// Only update the alias if the revision ID matches the ID that's specified. Use this option to avoid modifying an alias that has changed since you last read it.
        public let revisionId: String?
        /// The routing configuration of the alias.
        public let routingConfig: AliasRoutingConfiguration?

        public init(description: String? = nil, functionName: String, functionVersion: String? = nil, name: String, revisionId: String? = nil, routingConfig: AliasRoutingConfiguration? = nil) {
            self.description = description
            self.functionName = functionName
            self.functionVersion = functionVersion
            self.name = name
            self.revisionId = revisionId
            self.routingConfig = routingConfig
        }

        public func validate(name: String) throws {
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, max: 1024)
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, min: 1)
            try self.validate(self.functionVersion, name: "functionVersion", parent: name, pattern: "^(\\$LATEST|[0-9]+)$")
            try self.validate(self.name, name: "name", parent: name, max: 128)
            try self.validate(self.name, name: "name", parent: name, min: 1)
            try self.validate(self.name, name: "name", parent: name, pattern: "^(?!^[0-9]+$)([a-zA-Z0-9-_]+)$")
            try self.routingConfig?.validate(name: "\(name).routingConfig")
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case functionVersion = "FunctionVersion"
            case revisionId = "RevisionId"
            case routingConfig = "RoutingConfig"
        }
    }

    public struct UpdateCodeSigningConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "codeSigningConfigArn", location: .uri("CodeSigningConfigArn"))
        ]

        /// Signing profiles for this code signing configuration.
        public let allowedPublishers: AllowedPublishers?
        /// The The Amazon Resource Name (ARN) of the code signing configuration.
        public let codeSigningConfigArn: String
        /// The code signing policy.
        public let codeSigningPolicies: CodeSigningPolicies?
        /// Descriptive name for this code signing configuration.
        public let description: String?

        public init(allowedPublishers: AllowedPublishers? = nil, codeSigningConfigArn: String, codeSigningPolicies: CodeSigningPolicies? = nil, description: String? = nil) {
            self.allowedPublishers = allowedPublishers
            self.codeSigningConfigArn = codeSigningConfigArn
            self.codeSigningPolicies = codeSigningPolicies
            self.description = description
        }

        public func validate(name: String) throws {
            try self.allowedPublishers?.validate(name: "\(name).allowedPublishers")
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, max: 200)
            try self.validate(self.codeSigningConfigArn, name: "codeSigningConfigArn", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}((-gov)|(-iso(b?)))?-[a-z]+-\\d{1}:\\d{12}:code-signing-config:csc-[a-z0-9]{17}$")
            try self.validate(self.description, name: "description", parent: name, max: 256)
        }

        private enum CodingKeys: String, CodingKey {
            case allowedPublishers = "AllowedPublishers"
            case codeSigningPolicies = "CodeSigningPolicies"
            case description = "Description"
        }
    }

    public struct UpdateCodeSigningConfigResponse: AWSDecodableShape {
        /// The code signing configuration
        public let codeSigningConfig: CodeSigningConfig

        public init(codeSigningConfig: CodeSigningConfig) {
            self.codeSigningConfig = codeSigningConfig
        }

        private enum CodingKeys: String, CodingKey {
            case codeSigningConfig = "CodeSigningConfig"
        }
    }

    public struct UpdateEventSourceMappingRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "uuid", location: .uri("UUID"))
        ]

        /// The maximum number of records in each batch that Lambda pulls from your stream or queue and sends to your function. Lambda passes all of the records in the batch to the function in a single call, up to the payload limit for synchronous invocation (6 MB).    Amazon Kinesis - Default 100. Max 10,000.    Amazon DynamoDB Streams - Default 100. Max 10,000.    Amazon Simple Queue Service - Default 10. For standard queues the max is 10,000. For FIFO queues the max is 10.    Amazon Managed Streaming for Apache Kafka - Default 100. Max 10,000.    Self-managed Apache Kafka - Default 100. Max 10,000.    Amazon MQ (ActiveMQ and RabbitMQ) - Default 100. Max 10,000.
        public let batchSize: Int?
        /// (Streams only) If the function returns an error, split the batch in two and retry.
        public let bisectBatchOnFunctionError: Bool?
        /// (Streams only) An Amazon SQS queue or Amazon SNS topic destination for discarded records.
        public let destinationConfig: DestinationConfig?
        /// When true, the event source mapping is active. When false, Lambda pauses polling and invocation. Default: True
        public let enabled: Bool?
        /// An object that defines the filter criteria that determine whether Lambda should process an event. For more information, see Lambda event filtering.
        public let filterCriteria: FilterCriteria?
        /// The name of the Lambda function.  Name formats     Function name - MyFunction.    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.    Version or Alias ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD.    Partial ARN - 123456789012:function:MyFunction.   The length constraint applies only to the full ARN. If you specify only the function name, it's limited to 64 characters in length.
        public let functionName: String?
        /// (Streams and Amazon SQS) A list of current response type enums applied to the event source mapping.
        public let functionResponseTypes: [FunctionResponseType]?
        /// The maximum amount of time, in seconds, that Lambda spends gathering records before invoking the function. You can configure MaximumBatchingWindowInSeconds to any value from 0 seconds to 300 seconds in increments of seconds. For streams and Amazon SQS event sources, the default batching window is 0 seconds. For Amazon MSK, Self-managed Apache Kafka, and Amazon MQ event sources, the default batching window is 500 ms. Note that because you can only change MaximumBatchingWindowInSeconds in increments of seconds, you cannot revert back to the 500 ms default batching window after you have changed it. To restore the default batching window, you must create a new event source mapping. Related setting: For streams and Amazon SQS event sources, when you set BatchSize to a value greater than 10, you must set MaximumBatchingWindowInSeconds to at least 1.
        public let maximumBatchingWindowInSeconds: Int?
        /// (Streams only) Discard records older than the specified age. The default value is infinite (-1).
        public let maximumRecordAgeInSeconds: Int?
        /// (Streams only) Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records are retried until the record expires.
        public let maximumRetryAttempts: Int?
        /// (Streams only) The number of batches to process from each shard concurrently.
        public let parallelizationFactor: Int?
        /// An array of authentication protocols or VPC components required to secure your event source.
        public let sourceAccessConfigurations: [SourceAccessConfiguration]?
        /// (Streams only) The duration in seconds of a processing window. The range is between 1 second and 900 seconds.
        public let tumblingWindowInSeconds: Int?
        /// The identifier of the event source mapping.
        public let uuid: String

        public init(batchSize: Int? = nil, bisectBatchOnFunctionError: Bool? = nil, destinationConfig: DestinationConfig? = nil, enabled: Bool? = nil, filterCriteria: FilterCriteria? = nil, functionName: String? = nil, functionResponseTypes: [FunctionResponseType]? = nil, maximumBatchingWindowInSeconds: Int? = nil, maximumRecordAgeInSeconds: Int? = nil, maximumRetryAttempts: Int? = nil, parallelizationFactor: Int? = nil, sourceAccessConfigurations: [SourceAccessConfiguration]? = nil, tumblingWindowInSeconds: Int? = nil, uuid: String) {
            self.batchSize = batchSize
            self.bisectBatchOnFunctionError = bisectBatchOnFunctionError
            self.destinationConfig = destinationConfig
            self.enabled = enabled
            self.filterCriteria = filterCriteria
            self.functionName = functionName
            self.functionResponseTypes = functionResponseTypes
            self.maximumBatchingWindowInSeconds = maximumBatchingWindowInSeconds
            self.maximumRecordAgeInSeconds = maximumRecordAgeInSeconds
            self.maximumRetryAttempts = maximumRetryAttempts
            self.parallelizationFactor = parallelizationFactor
            self.sourceAccessConfigurations = sourceAccessConfigurations
            self.tumblingWindowInSeconds = tumblingWindowInSeconds
            self.uuid = uuid
        }

        public func validate(name: String) throws {
            try self.validate(self.batchSize, name: "batchSize", parent: name, max: 10000)
            try self.validate(self.batchSize, name: "batchSize", parent: name, min: 1)
            try self.destinationConfig?.validate(name: "\(name).destinationConfig")
            try self.filterCriteria?.validate(name: "\(name).filterCriteria")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.functionResponseTypes, name: "functionResponseTypes", parent: name, max: 1)
            try self.validate(self.maximumBatchingWindowInSeconds, name: "maximumBatchingWindowInSeconds", parent: name, max: 300)
            try self.validate(self.maximumBatchingWindowInSeconds, name: "maximumBatchingWindowInSeconds", parent: name, min: 0)
            try self.validate(self.maximumRecordAgeInSeconds, name: "maximumRecordAgeInSeconds", parent: name, max: 604_800)
            try self.validate(self.maximumRecordAgeInSeconds, name: "maximumRecordAgeInSeconds", parent: name, min: -1)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, max: 10000)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, min: -1)
            try self.validate(self.parallelizationFactor, name: "parallelizationFactor", parent: name, max: 10)
            try self.validate(self.parallelizationFactor, name: "parallelizationFactor", parent: name, min: 1)
            try self.sourceAccessConfigurations?.forEach {
                try $0.validate(name: "\(name).sourceAccessConfigurations[]")
            }
            try self.validate(self.sourceAccessConfigurations, name: "sourceAccessConfigurations", parent: name, max: 22)
            try self.validate(self.tumblingWindowInSeconds, name: "tumblingWindowInSeconds", parent: name, max: 900)
            try self.validate(self.tumblingWindowInSeconds, name: "tumblingWindowInSeconds", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case batchSize = "BatchSize"
            case bisectBatchOnFunctionError = "BisectBatchOnFunctionError"
            case destinationConfig = "DestinationConfig"
            case enabled = "Enabled"
            case filterCriteria = "FilterCriteria"
            case functionName = "FunctionName"
            case functionResponseTypes = "FunctionResponseTypes"
            case maximumBatchingWindowInSeconds = "MaximumBatchingWindowInSeconds"
            case maximumRecordAgeInSeconds = "MaximumRecordAgeInSeconds"
            case maximumRetryAttempts = "MaximumRetryAttempts"
            case parallelizationFactor = "ParallelizationFactor"
            case sourceAccessConfigurations = "SourceAccessConfigurations"
            case tumblingWindowInSeconds = "TumblingWindowInSeconds"
        }
    }

    public struct UpdateFunctionCodeRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// The instruction set architecture that the function supports. Enter a string array with one of the valid values (arm64 or x86_64). The default value is x86_64.
        public let architectures: [Architecture]?
        /// Set to true to validate the request parameters and access permissions without modifying the function code.
        public let dryRun: Bool?
        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// URI of a container image in the Amazon ECR registry. Do not use for a function defined with a .zip file archive.
        public let imageUri: String?
        /// Set to true to publish a new version of the function after updating the code. This has the same effect as calling PublishVersion separately.
        public let publish: Bool?
        /// Update the function only if the revision ID matches the ID that's specified. Use this option to avoid modifying a function that has changed since you last read it.
        public let revisionId: String?
        /// An Amazon S3 bucket in the same Amazon Web Services Region as your function. The bucket can be in a different
        /// Amazon Web Services account. Use only with a function defined with a .zip file archive deployment package.
        public let s3Bucket: String?
        /// The Amazon S3 key of the deployment package. Use only with a function defined with a .zip file archive deployment package.
        public let s3Key: String?
        /// For versioned objects, the version of the deployment package object to use.
        public let s3ObjectVersion: String?
        /// The base64-encoded contents of the deployment package. Amazon Web Services SDK and CLI clients
        /// handle the encoding for you. Use only with a function defined with a .zip file archive deployment package.
        public let zipFile: AWSBase64Data?

        public init(architectures: [Architecture]? = nil, dryRun: Bool? = nil, functionName: String, imageUri: String? = nil, publish: Bool? = nil, revisionId: String? = nil, s3Bucket: String? = nil, s3Key: String? = nil, s3ObjectVersion: String? = nil, zipFile: AWSBase64Data? = nil) {
            self.architectures = architectures
            self.dryRun = dryRun
            self.functionName = functionName
            self.imageUri = imageUri
            self.publish = publish
            self.revisionId = revisionId
            self.s3Bucket = s3Bucket
            self.s3Key = s3Key
            self.s3ObjectVersion = s3ObjectVersion
            self.zipFile = zipFile
        }

        public func validate(name: String) throws {
            try self.validate(self.architectures, name: "architectures", parent: name, max: 1)
            try self.validate(self.architectures, name: "architectures", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, max: 63)
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, min: 3)
            try self.validate(self.s3Bucket, name: "s3Bucket", parent: name, pattern: "^[0-9A-Za-z\\.\\-_]*(?<!\\.)$")
            try self.validate(self.s3Key, name: "s3Key", parent: name, max: 1024)
            try self.validate(self.s3Key, name: "s3Key", parent: name, min: 1)
            try self.validate(self.s3ObjectVersion, name: "s3ObjectVersion", parent: name, max: 1024)
            try self.validate(self.s3ObjectVersion, name: "s3ObjectVersion", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case architectures = "Architectures"
            case dryRun = "DryRun"
            case imageUri = "ImageUri"
            case publish = "Publish"
            case revisionId = "RevisionId"
            case s3Bucket = "S3Bucket"
            case s3Key = "S3Key"
            case s3ObjectVersion = "S3ObjectVersion"
            case zipFile = "ZipFile"
        }
    }

    public struct UpdateFunctionConfigurationRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName"))
        ]

        /// A dead-letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events when they fail processing. For more information, see Dead-letter queues.
        public let deadLetterConfig: DeadLetterConfig?
        /// A description of the function.
        public let description: String?
        /// Environment variables that are accessible from function code during execution.
        public let environment: Environment?
        /// The size of the function's /tmp directory in MB. The default value is 512, but can be any whole number between 512 and 10,240 MB.
        public let ephemeralStorage: EphemeralStorage?
        /// Connection settings for an Amazon EFS file system.
        public let fileSystemConfigs: [FileSystemConfig]?
        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The name of the method within your code that Lambda calls to run your function.
        /// Handler is required if the deployment package is a .zip file archive. The format includes the file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information, see Lambda programming model.
        public let handler: String?
        ///  Container image configuration values that override the values in the container image Docker file.
        public let imageConfig: ImageConfig?
        /// The ARN of the Key Management Service (KMS) key that's used to encrypt your function's environment variables. If it's not provided, Lambda uses a default service key.
        public let kmsKeyArn: String?
        /// A list of function layers to add to the function's execution environment. Specify each layer by its ARN, including the version.
        public let layers: [String]?
        /// The amount of memory available to the function at runtime. Increasing the function memory also increases its CPU allocation. The default value is 128 MB. The value can be any multiple of 1 MB.
        public let memorySize: Int?
        /// Update the function only if the revision ID matches the ID that's specified. Use this option to avoid modifying a function that has changed since you last read it.
        public let revisionId: String?
        /// The Amazon Resource Name (ARN) of the function's execution role.
        public let role: String?
        /// The identifier of the function's runtime. Runtime is required if the deployment package is a .zip file archive.
        public let runtime: Runtime?
        /// The function's SnapStart setting.
        public let snapStart: SnapStart?
        /// The amount of time (in seconds) that Lambda allows a function to run before stopping it. The default is 3 seconds. The maximum allowed value is 900 seconds. For more information, see Lambda execution environment.
        public let timeout: Int?
        /// Set Mode to Active to sample and trace a subset of incoming requests with
        /// X-Ray.
        public let tracingConfig: TracingConfig?
        /// For network connectivity to Amazon Web Services resources in a VPC, specify a list of security groups and subnets in the VPC. When you connect a function to a VPC, it can access resources and the internet only through that VPC. For more information, see Configuring a Lambda function to access resources in a VPC.
        public let vpcConfig: VpcConfig?

        public init(deadLetterConfig: DeadLetterConfig? = nil, description: String? = nil, environment: Environment? = nil, ephemeralStorage: EphemeralStorage? = nil, fileSystemConfigs: [FileSystemConfig]? = nil, functionName: String, handler: String? = nil, imageConfig: ImageConfig? = nil, kmsKeyArn: String? = nil, layers: [String]? = nil, memorySize: Int? = nil, revisionId: String? = nil, role: String? = nil, runtime: Runtime? = nil, snapStart: SnapStart? = nil, timeout: Int? = nil, tracingConfig: TracingConfig? = nil, vpcConfig: VpcConfig? = nil) {
            self.deadLetterConfig = deadLetterConfig
            self.description = description
            self.environment = environment
            self.ephemeralStorage = ephemeralStorage
            self.fileSystemConfigs = fileSystemConfigs
            self.functionName = functionName
            self.handler = handler
            self.imageConfig = imageConfig
            self.kmsKeyArn = kmsKeyArn
            self.layers = layers
            self.memorySize = memorySize
            self.revisionId = revisionId
            self.role = role
            self.runtime = runtime
            self.snapStart = snapStart
            self.timeout = timeout
            self.tracingConfig = tracingConfig
            self.vpcConfig = vpcConfig
        }

        public func validate(name: String) throws {
            try self.deadLetterConfig?.validate(name: "\(name).deadLetterConfig")
            try self.validate(self.description, name: "description", parent: name, max: 256)
            try self.environment?.validate(name: "\(name).environment")
            try self.ephemeralStorage?.validate(name: "\(name).ephemeralStorage")
            try self.fileSystemConfigs?.forEach {
                try $0.validate(name: "\(name).fileSystemConfigs[]")
            }
            try self.validate(self.fileSystemConfigs, name: "fileSystemConfigs", parent: name, max: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.handler, name: "handler", parent: name, max: 128)
            try self.validate(self.handler, name: "handler", parent: name, pattern: "^[^\\s]+$")
            try self.imageConfig?.validate(name: "\(name).imageConfig")
            try self.validate(self.kmsKeyArn, name: "kmsKeyArn", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()$")
            try self.layers?.forEach {
                try validate($0, name: "layers[]", parent: name, max: 140)
                try validate($0, name: "layers[]", parent: name, min: 1)
                try validate($0, name: "layers[]", parent: name, pattern: "^arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\\d{12}:layer:[a-zA-Z0-9-_]+:[0-9]+$")
            }
            try self.validate(self.memorySize, name: "memorySize", parent: name, max: 10240)
            try self.validate(self.memorySize, name: "memorySize", parent: name, min: 128)
            try self.validate(self.role, name: "role", parent: name, pattern: "^arn:(aws[a-zA-Z-]*)?:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+$")
            try self.validate(self.timeout, name: "timeout", parent: name, min: 1)
            try self.vpcConfig?.validate(name: "\(name).vpcConfig")
        }

        private enum CodingKeys: String, CodingKey {
            case deadLetterConfig = "DeadLetterConfig"
            case description = "Description"
            case environment = "Environment"
            case ephemeralStorage = "EphemeralStorage"
            case fileSystemConfigs = "FileSystemConfigs"
            case handler = "Handler"
            case imageConfig = "ImageConfig"
            case kmsKeyArn = "KMSKeyArn"
            case layers = "Layers"
            case memorySize = "MemorySize"
            case revisionId = "RevisionId"
            case role = "Role"
            case runtime = "Runtime"
            case snapStart = "SnapStart"
            case timeout = "Timeout"
            case tracingConfig = "TracingConfig"
            case vpcConfig = "VpcConfig"
        }
    }

    public struct UpdateFunctionEventInvokeConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// A destination for events after they have been sent to a function for processing.  Destinations     Function - The Amazon Resource Name (ARN) of a Lambda function.    Queue - The ARN of an SQS queue.    Topic - The ARN of an SNS topic.    Event Bus - The ARN of an Amazon EventBridge event bus.
        public let destinationConfig: DestinationConfig?
        /// The name of the Lambda function, version, or alias.  Name formats     Function name - my-function (name-only), my-function:v1 (with alias).    Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN - 123456789012:function:my-function.   You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The maximum age of a request that Lambda sends to a function for processing.
        public let maximumEventAgeInSeconds: Int?
        /// The maximum number of times to retry when the function returns an error.
        public let maximumRetryAttempts: Int?
        /// A version number or alias name.
        public let qualifier: String?

        public init(destinationConfig: DestinationConfig? = nil, functionName: String, maximumEventAgeInSeconds: Int? = nil, maximumRetryAttempts: Int? = nil, qualifier: String? = nil) {
            self.destinationConfig = destinationConfig
            self.functionName = functionName
            self.maximumEventAgeInSeconds = maximumEventAgeInSeconds
            self.maximumRetryAttempts = maximumRetryAttempts
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.destinationConfig?.validate(name: "\(name).destinationConfig")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.maximumEventAgeInSeconds, name: "maximumEventAgeInSeconds", parent: name, max: 21600)
            try self.validate(self.maximumEventAgeInSeconds, name: "maximumEventAgeInSeconds", parent: name, min: 60)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, max: 2)
            try self.validate(self.maximumRetryAttempts, name: "maximumRetryAttempts", parent: name, min: 0)
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(|[a-zA-Z0-9$_-]+)$")
        }

        private enum CodingKeys: String, CodingKey {
            case destinationConfig = "DestinationConfig"
            case maximumEventAgeInSeconds = "MaximumEventAgeInSeconds"
            case maximumRetryAttempts = "MaximumRetryAttempts"
        }
    }

    public struct UpdateFunctionUrlConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "functionName", location: .uri("FunctionName")),
            AWSMemberEncoding(label: "qualifier", location: .querystring("Qualifier"))
        ]

        /// The type of authentication that your function URL uses. Set to AWS_IAM if you want to restrict access to authenticated IAM users only. Set to NONE if you want to bypass IAM authentication to create a public endpoint. For more information, see Security and auth model for Lambda function URLs.
        public let authType: FunctionUrlAuthType?
        /// The cross-origin resource sharing (CORS) settings for your function URL.
        public let cors: Cors?
        /// The name of the Lambda function.  Name formats     Function name – my-function.    Function ARN – arn:aws:lambda:us-west-2:123456789012:function:my-function.    Partial ARN – 123456789012:function:my-function.   The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
        public let functionName: String
        /// The alias name.
        public let qualifier: String?

        public init(authType: FunctionUrlAuthType? = nil, cors: Cors? = nil, functionName: String, qualifier: String? = nil) {
            self.authType = authType
            self.cors = cors
            self.functionName = functionName
            self.qualifier = qualifier
        }

        public func validate(name: String) throws {
            try self.cors?.validate(name: "\(name).cors")
            try self.validate(self.functionName, name: "functionName", parent: name, max: 140)
            try self.validate(self.functionName, name: "functionName", parent: name, min: 1)
            try self.validate(self.functionName, name: "functionName", parent: name, pattern: "^(arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\\d{1}:)?(\\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\\$LATEST|[a-zA-Z0-9-_]+))?$")
            try self.validate(self.qualifier, name: "qualifier", parent: name, max: 128)
            try self.validate(self.qualifier, name: "qualifier", parent: name, min: 1)
            try self.validate(self.qualifier, name: "qualifier", parent: name, pattern: "^(^\\$LATEST$)|((?!^[0-9]+$)([a-zA-Z0-9-_]+))$")
        }

        private enum CodingKeys: String, CodingKey {
            case authType = "AuthType"
            case cors = "Cors"
        }
    }

    public struct UpdateFunctionUrlConfigResponse: AWSDecodableShape {
        /// The type of authentication that your function URL uses. Set to AWS_IAM if you want to restrict access to authenticated IAM users only. Set to NONE if you want to bypass IAM authentication to create a public endpoint. For more information, see Security and auth model for Lambda function URLs.
        public let authType: FunctionUrlAuthType
        /// The cross-origin resource sharing (CORS) settings for your function URL.
        public let cors: Cors?
        /// When the function URL was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let creationTime: String
        /// The Amazon Resource Name (ARN) of your function.
        public let functionArn: String
        /// The HTTP URL endpoint for your function.
        public let functionUrl: String
        /// When the function URL configuration was last updated, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
        public let lastModifiedTime: String

        public init(authType: FunctionUrlAuthType, cors: Cors? = nil, creationTime: String, functionArn: String, functionUrl: String, lastModifiedTime: String) {
            self.authType = authType
            self.cors = cors
            self.creationTime = creationTime
            self.functionArn = functionArn
            self.functionUrl = functionUrl
            self.lastModifiedTime = lastModifiedTime
        }

        private enum CodingKeys: String, CodingKey {
            case authType = "AuthType"
            case cors = "Cors"
            case creationTime = "CreationTime"
            case functionArn = "FunctionArn"
            case functionUrl = "FunctionUrl"
            case lastModifiedTime = "LastModifiedTime"
        }
    }

    public struct VpcConfig: AWSEncodableShape {
        /// A list of VPC security group IDs.
        public let securityGroupIds: [String]?
        /// A list of VPC subnet IDs.
        public let subnetIds: [String]?

        public init(securityGroupIds: [String]? = nil, subnetIds: [String]? = nil) {
            self.securityGroupIds = securityGroupIds
            self.subnetIds = subnetIds
        }

        public func validate(name: String) throws {
            try self.validate(self.securityGroupIds, name: "securityGroupIds", parent: name, max: 5)
            try self.validate(self.subnetIds, name: "subnetIds", parent: name, max: 16)
        }

        private enum CodingKeys: String, CodingKey {
            case securityGroupIds = "SecurityGroupIds"
            case subnetIds = "SubnetIds"
        }
    }

    public struct VpcConfigResponse: AWSDecodableShape {
        /// A list of VPC security group IDs.
        public let securityGroupIds: [String]?
        /// A list of VPC subnet IDs.
        public let subnetIds: [String]?
        /// The ID of the VPC.
        public let vpcId: String?

        public init(securityGroupIds: [String]? = nil, subnetIds: [String]? = nil, vpcId: String? = nil) {
            self.securityGroupIds = securityGroupIds
            self.subnetIds = subnetIds
            self.vpcId = vpcId
        }

        private enum CodingKeys: String, CodingKey {
            case securityGroupIds = "SecurityGroupIds"
            case subnetIds = "SubnetIds"
            case vpcId = "VpcId"
        }
    }
}

// MARK: - Errors

/// Error enum for Lambda
public struct LambdaErrorType: AWSErrorType {
    enum Code: String {
        case codeSigningConfigNotFoundException = "CodeSigningConfigNotFoundException"
        case codeStorageExceededException = "CodeStorageExceededException"
        case codeVerificationFailedException = "CodeVerificationFailedException"
        case ec2AccessDeniedException = "EC2AccessDeniedException"
        case ec2ThrottledException = "EC2ThrottledException"
        case ec2UnexpectedException = "EC2UnexpectedException"
        case efsMountConnectivityException = "EFSMountConnectivityException"
        case efsMountFailureException = "EFSMountFailureException"
        case efsMountTimeoutException = "EFSMountTimeoutException"
        case efsioException = "EFSIOException"
        case eniLimitReachedException = "ENILimitReachedException"
        case invalidCodeSignatureException = "InvalidCodeSignatureException"
        case invalidParameterValueException = "InvalidParameterValueException"
        case invalidRequestContentException = "InvalidRequestContentException"
        case invalidRuntimeException = "InvalidRuntimeException"
        case invalidSecurityGroupIDException = "InvalidSecurityGroupIDException"
        case invalidSubnetIDException = "InvalidSubnetIDException"
        case invalidZipFileException = "InvalidZipFileException"
        case kmsAccessDeniedException = "KMSAccessDeniedException"
        case kmsDisabledException = "KMSDisabledException"
        case kmsInvalidStateException = "KMSInvalidStateException"
        case kmsNotFoundException = "KMSNotFoundException"
        case policyLengthExceededException = "PolicyLengthExceededException"
        case preconditionFailedException = "PreconditionFailedException"
        case provisionedConcurrencyConfigNotFoundException = "ProvisionedConcurrencyConfigNotFoundException"
        case requestTooLargeException = "RequestTooLargeException"
        case resourceConflictException = "ResourceConflictException"
        case resourceInUseException = "ResourceInUseException"
        case resourceNotFoundException = "ResourceNotFoundException"
        case resourceNotReadyException = "ResourceNotReadyException"
        case serviceException = "ServiceException"
        case snapStartException = "SnapStartException"
        case snapStartNotReadyException = "SnapStartNotReadyException"
        case snapStartTimeoutException = "SnapStartTimeoutException"
        case subnetIPAddressLimitReachedException = "SubnetIPAddressLimitReachedException"
        case tooManyRequestsException = "TooManyRequestsException"
        case unsupportedMediaTypeException = "UnsupportedMediaTypeException"
    }

    private let error: Code
    public let context: AWSErrorContext?

    /// initialize Lambda
    public init?(errorCode: String, context: AWSErrorContext) {
        guard let error = Code(rawValue: errorCode) else { return nil }
        self.error = error
        self.context = context
    }

    internal init(_ error: Code) {
        self.error = error
        self.context = nil
    }

    /// return error code string
    public var errorCode: String { self.error.rawValue }

    /// The specified code signing configuration does not exist.
    public static var codeSigningConfigNotFoundException: Self { .init(.codeSigningConfigNotFoundException) }
    /// Your Amazon Web Services account has exceeded its maximum total code size. For more information, see Lambda quotas.
    public static var codeStorageExceededException: Self { .init(.codeStorageExceededException) }
    /// The code signature failed one or more of the validation checks for signature mismatch or expiry, and the code signing policy is set to ENFORCE. Lambda blocks the deployment.
    public static var codeVerificationFailedException: Self { .init(.codeVerificationFailedException) }
    /// Need additional permissions to configure VPC settings.
    public static var ec2AccessDeniedException: Self { .init(.ec2AccessDeniedException) }
    /// Amazon EC2 throttled Lambda during Lambda function initialization using the execution role provided for the function.
    public static var ec2ThrottledException: Self { .init(.ec2ThrottledException) }
    /// Lambda received an unexpected Amazon EC2 client exception while setting up for the Lambda function.
    public static var ec2UnexpectedException: Self { .init(.ec2UnexpectedException) }
    /// The Lambda function couldn&#39;t make a network connection to the configured file system.
    public static var efsMountConnectivityException: Self { .init(.efsMountConnectivityException) }
    /// The Lambda function couldn&#39;t mount the configured file system due to a permission or configuration issue.
    public static var efsMountFailureException: Self { .init(.efsMountFailureException) }
    /// The Lambda function made a network connection to the configured file system, but the mount operation timed out.
    public static var efsMountTimeoutException: Self { .init(.efsMountTimeoutException) }
    /// An error occurred when reading from or writing to a connected file system.
    public static var efsioException: Self { .init(.efsioException) }
    /// Lambda couldn&#39;t create an elastic network interface in the VPC, specified as part of Lambda function configuration, because the limit for network interfaces has been reached. For more information, see Lambda quotas.
    public static var eniLimitReachedException: Self { .init(.eniLimitReachedException) }
    /// The code signature failed the integrity check. If the integrity check fails, then Lambda blocks deployment, even if the code signing policy is set to WARN.
    public static var invalidCodeSignatureException: Self { .init(.invalidCodeSignatureException) }
    /// One of the parameters in the request is not valid.
    public static var invalidParameterValueException: Self { .init(.invalidParameterValueException) }
    /// The request body could not be parsed as JSON.
    public static var invalidRequestContentException: Self { .init(.invalidRequestContentException) }
    /// The runtime or runtime version specified is not supported.
    public static var invalidRuntimeException: Self { .init(.invalidRuntimeException) }
    /// The security group ID provided in the Lambda function VPC configuration is not valid.
    public static var invalidSecurityGroupIDException: Self { .init(.invalidSecurityGroupIDException) }
    /// The subnet ID provided in the Lambda function VPC configuration is not valid.
    public static var invalidSubnetIDException: Self { .init(.invalidSubnetIDException) }
    /// Lambda could not unzip the deployment package.
    public static var invalidZipFileException: Self { .init(.invalidZipFileException) }
    /// Lambda couldn&#39;t decrypt the environment variables because KMS access was denied. Check the Lambda function&#39;s KMS permissions.
    public static var kmsAccessDeniedException: Self { .init(.kmsAccessDeniedException) }
    /// Lambda couldn&#39;t decrypt the environment variables because the KMS key used is disabled. Check the Lambda function&#39;s KMS key settings.
    public static var kmsDisabledException: Self { .init(.kmsDisabledException) }
    /// Lambda couldn&#39;t decrypt the environment variables because the state of the KMS key used is not valid for Decrypt. Check the function&#39;s KMS key settings.
    public static var kmsInvalidStateException: Self { .init(.kmsInvalidStateException) }
    /// Lambda couldn&#39;t decrypt the environment variables because the KMS key was not found. Check the function&#39;s KMS key settings.
    public static var kmsNotFoundException: Self { .init(.kmsNotFoundException) }
    /// The permissions policy for the resource is too large. For more information, see Lambda quotas.
    public static var policyLengthExceededException: Self { .init(.policyLengthExceededException) }
    /// The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the GetFunction or the GetAlias API operation to retrieve the latest RevisionId for your resource.
    public static var preconditionFailedException: Self { .init(.preconditionFailedException) }
    /// The specified configuration does not exist.
    public static var provisionedConcurrencyConfigNotFoundException: Self { .init(.provisionedConcurrencyConfigNotFoundException) }
    /// The request payload exceeded the Invoke request body JSON input quota. For more information, see Lambda quotas.
    public static var requestTooLargeException: Self { .init(.requestTooLargeException) }
    /// The resource already exists, or another operation is in progress.
    public static var resourceConflictException: Self { .init(.resourceConflictException) }
    /// The operation conflicts with the resource&#39;s availability. For example, you tried to update an event source mapping in the CREATING state, or you tried to delete an event source mapping currently UPDATING.
    public static var resourceInUseException: Self { .init(.resourceInUseException) }
    /// The resource specified in the request does not exist.
    public static var resourceNotFoundException: Self { .init(.resourceNotFoundException) }
    /// The function is inactive and its VPC connection is no longer available. Wait for the VPC connection to reestablish and try again.
    public static var resourceNotReadyException: Self { .init(.resourceNotReadyException) }
    /// The Lambda service encountered an internal error.
    public static var serviceException: Self { .init(.serviceException) }
    /// The runtime restore hook encountered an error. For more information, check the Amazon CloudWatch logs.
    public static var snapStartException: Self { .init(.snapStartException) }
    /// Lambda is initializing your function. You can invoke the function when the function state becomes Active.
    public static var snapStartNotReadyException: Self { .init(.snapStartNotReadyException) }
    /// The runtime restore hook failed to complete within the timeout limit (2 seconds).
    public static var snapStartTimeoutException: Self { .init(.snapStartTimeoutException) }
    /// Lambda couldn&#39;t set up VPC access for the Lambda function because one or more configured subnets has no available IP addresses.
    public static var subnetIPAddressLimitReachedException: Self { .init(.subnetIPAddressLimitReachedException) }
    /// The request throughput limit was exceeded. For more information, see Lambda quotas.
    public static var tooManyRequestsException: Self { .init(.tooManyRequestsException) }
    /// The content type of the Invoke request body is not JSON.
    public static var unsupportedMediaTypeException: Self { .init(.unsupportedMediaTypeException) }
}

extension LambdaErrorType: Equatable {
    public static func == (lhs: LambdaErrorType, rhs: LambdaErrorType) -> Bool {
        lhs.error == rhs.error
    }
}

extension LambdaErrorType: CustomStringConvertible {
    public var description: String {
        return "\(self.error.rawValue): \(self.message ?? "")"
    }
}
